ThinkPHP5的数据验证

Published on 2016 - 12 - 21

验证器

概述

ThinkPHP5.0验证使用独立的\think\Validate类或者验证器进行验证。

独立验证

任何时候,都可以使用Validate类进行独立的验证操作,例如:

$validate = new Validate([
    'name'  => 'require|max:25',
    'email' => 'email'
]);
$data = [
    'name'  => 'thinkphp',
    'email' => 'thinkphp@qq.com'
];
if (!$validate->check($data)) {
    dump($validate->getError());
}

验证器

这是5.0推荐的验证方式,为具体的验证场景或者数据表定义好验证器类,直接调用验证类的check方法即可完成验证,下面是一个例子:

我们定义一个\app\index\validate\User验证器类用于User的验证。

namespace app\index\validate;

use think\Validate;

class User extends Validate
{
    protected $rule = [
        'name'  =>  'require|max:25',
        'email' =>  'email',
    ];

}

在需要进行User验证的地方,添加如下代码即可:

$data = [
    'name'=>'thinkphp',
    'email'=>'thinkphp@qq.com'
];

$validate = Loader::validate('User');

if(!$validate->check($data)){
    dump($validate->getError());
}

使用助手函数实例化验证器

$validate = validate('User');

验证规则

设置规则

可以在实例化Validate类的时候传入验证规则,例如:

$rules = [
    'name'  => 'require|max:25',
    'age'   => 'number|between:1,120',
];
$validate = new Validate($rules);

也可以使用rule方法动态添加规则,例如:

$rules = [
    'name'  => 'require|max:25',
    'age'   => 'number|between:1,120',
];
$validate = new Validate($rules);
$validate->rule('zip', '/^\d{6}$/');
$validate->rule([
    'email'   => 'email',
]);

规则定义

规则定义支持下面两种方式:

$rules = [
    'name'  => 'require|max:25',
    'age'   => 'number|between:1,120',
];
$validate = new Validate($rules);

对于一个字段可以设置多个验证规则,使用|分割。

或者采用数组方式定义多个规则(适用于你的验证规则中有|的情况)

$rules = [
    'name'  => ['require','max'=>25],
    'age'   => ['number','between'=>'1,120'],
];
$validate = new Validate($rules);

属性定义

通常情况下,我们实际在定义验证类的时候,可以通过属性的方式直接定义验证规则等信息,例如:

namespace app\index\validate;

use think\Validate;

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

    protected $message  =   [
        'name.require' => '名称必须',
        'name.max'     => '名称最多不能超过25个字符',
        'age.number'   => '年龄必须是数字',
        'age.between'  => '年龄只能在1-120之间',
        'email'        => '邮箱格式错误',    
    ];

}

验证数据

下面是一个典型的验证数据的例子:

$rule = [
    'name'  => 'require|max:25',
    'age'   => 'number|between:1,120',
    'email' => 'email',
];

$msg = [
    'name.require' => '名称必须',
    'name.max'     => '名称最多不能超过25个字符',
    'age.number'   => '年龄必须是数字',
    'age.between'  => '年龄只能在1-120之间',
    'email'        => '邮箱格式错误',
];

$data = [
    'name'  => 'thinkphp',
    'age'   => 10,
    'email' => 'thinkphp@qq.com',
];

$validate = new Validate($rule, $msg);
$result   = $validate->check($data);

如果需要批量验证,可以使用:

$validate = new Validate($rule, $msg);
$result   = $validate->batch()->check($data);

批量验证如果验证不通过,返回的是一个错误信息的数组。

如果你定义了User验证器类的话,可以使用下面的验证代码:

$data = [
    'name'  => 'thinkphp',
    'age'   => 10,
    'email' => 'thinkphp@qq.com',
];
$validate = Loader::validate('User');
if(!$validate->check($data)){
    dump($validate->getError());
}

闭包函数验证

可以对某个字段使用闭包验证,例如:

$validate = new \think\Validate([
    'name'  => function($value,$rule) { 
        return $rule==$value ? true : false;
    },
]);

自定义验证规则

系统内置了一些常用的规则,如果还不够用,可以自己扩展验证规则。

如果使用了验证器的话,可以直接在验证器类添加自己的验证方法,例如:

namespace app\index\validate;

use think\Validate;

class User extends Validate
{
    protected $rule = [
        'name'  =>  'checkName:thinkphp',
        'email' =>  'email',
    ];

    protected $message = [
        'name'  =>  '用户名必须',
        'email' =>  '邮箱格式错误',
    ];

    // 自定义验证规则
    protected function checkName($value,$rule,$data)
    {
        return $rule == $value ? true : '名称错误';
    }
}

验证方法支持传入的参数包括 $value $rule 和 $data三个,并且第三个参数支持引用传参。

并且需要注意的是,自定义的验证规则方法名不能和已有的规则冲突。

接下来,就可以这样进行验证:

$validate = Loader::validate('User');
if(!$validate->check($data)){
    dump($validate->getError());
}

如果没有使用验证器类,则支持使用extend方法扩展验证规则,例如:

$validate = new Validate(['name' => 'checkName:1']);
$validate->extend('checkName', function ($value, $rule) {
    return $rule == $value ? true : '名称错误';
});
$data   = ['name' => 1];
$result = $validate->check($data);

支持批量注册验证规则,例如:

$validate = new Validate(['name' => 'checkName:1']);
$validate->extend([
    'checkName'=> function ($value, $rule) {
    return $rule == $value ? true : '名称错误';
},
    'checkStatus'=> [$this,'checkStatus']
]);
$data   = ['name' => 1];
$result = $validate->check($data);

错误信息

验证规则的错误提示信息有三种方式可以定义,如下:

使用默认的错误提示信息

如果没有定义任何的验证提示信息,系统会显示默认的错误信息,例如:

$rule = [
    'name'  => 'require|max:25',
    'age'   => 'number|between:1,120',
    'email' => 'email',
];

$data = [
    'name'  => 'thinkphp',
    'age'   => 121,
    'email' => 'thinkphp@qq.com',
];
$validate = new Validate($rule);
$result   = $validate->check($data);
if(!$result){
    echo $validate->getError();
}

会输出 age只能在 1 - 120 之间。

可以给age字段设置中文名,例如:

$rule = [
    'name'  => 'require|max:25',
    'age|年龄'   => 'number|between:1,120',
    'email' => 'email',
];

$data = [
    'name'  => 'thinkphp',
    'age'   => 121,
    'email' => 'thinkphp@qq.com',
];
$validate = new Validate($rule);
$result   = $validate->check($data);
if(!$result){
    echo $validate->getError();
}

会输出 年龄只能在 1 - 120 之间。

验证规则和提示信息分开定义

如果要输出自定义的错误信息,有两种方式可以设置。下面的一种方式是验证规则和提示信息分开定义:

$rule = [
    'name'  => 'require|max:25',
    'age'   => 'number|between:1,120',
    'email' => 'email',
];
$msg = [
    'name.require' => '名称必须',
    'name.max'     => '名称最多不能超过25个字符',
    'age.number'   => '年龄必须是数字',
    'age.between'  => '年龄必须在1~120之间',
    'email'        => '邮箱格式错误',
];
$data = [
    'name'  => 'thinkphp',
    'age'   => 121,
    'email' => 'thinkphp@qq.com',
];
$validate = new Validate($rule,$msg);
$result   = $validate->check($data);
if(!$result){
    echo $validate->getError();
}

会输出 年龄必须在1~120之间。

验证规则和提示信息一起定义

可以支持验证规则和错误信息一起定义的方式,如下:

$rule = [
    ['name','require|max:25','名称必须|名称最多不能超过25个字符'],
    ['age','number|between:1,120','年龄必须是数字|年龄必须在1~120之间'],
    ['email','email','邮箱格式错误']
];

$data = [
    'name'  => 'thinkphp',
    'age'   => 121,
    'email' => 'thinkphp@qq.com',
];
$validate = new Validate($rule);
$result   = $validate->check($data);
if(!$result){
    echo $validate->getError();
}

验证场景

可以在定义验证规则的时候定义场景,并且验证不同场景的数据,例如:

$rule = [
    'name'  => 'require|max:25',
    'age'   => 'number|between:1,120',
    'email' => 'email',
];
$msg = [
    'name.require' => '名称必须',
    'name.max'     => '名称最多不能超过25个字符',
    'age.number'   => '年龄必须是数字',
    'age.between'  => '年龄只能在1-120之间',
    'email'        => '邮箱格式错误',
];
$data = [
    'name'  => 'thinkphp',
    'age'   => 10,
    'email' => 'thinkphp@qq.com',
];
$validate = new Validate($rule);
$validate->scene('edit', ['name', 'age']);
$result = $validate->scene('edit')->check($data);

表示验证edit场景(该场景定义只需要验证name和age字段)。

如果使用了验证器,可以直接在类里面定义场景,例如:

namespace app\index\validate;

use think\Validate;

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

    protected $message  =   [
        'name.require' => '名称必须',
        'name.max'     => '名称最多不能超过25个字符',
        'age.number'   => '年龄必须是数字',
        'age.between'  => '年龄只能在1-120之间',
        'email'        => '邮箱格式错误',    
    ];

    protected $scene = [
        'edit'  =>  ['name','age'],
    ];
}

可以在定义场景的时候对某些字段的规则重新设置,例如:

namespace app\index\validate;

use think\Validate;

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

    protected $message  =   [
        'name.require' => '名称必须',
        'name.max'     => '名称最多不能超过25个字符',
        'age.number'   => '年龄必须是数字',
        'age.between'  => '年龄只能在1-120之间',
        'email'        => '邮箱格式错误',    
    ];

    protected $scene = [
        'edit'  =>  ['name','age'=>'require|number|between:1,120'],
    ];

}

可以对场景设置一个回调方法,用于动态设置要验证的字段,例如:

$rule = [
    'name'  => 'require|max:25',
    'age'   => 'number|between:1,120',
    'email' => 'email',
];
$msg = [
    'name.require' => '名称必须',
    'name.max'     => '名称最多不能超过25个字符',
    'age.number'   => '年龄必须是数字',
    'age.between'  => '年龄只能在1-120之间',
    'email'        => '邮箱格式错误',
];
$data = [
    'name'  => 'thinkphp',
    'age'   => 10,
    'email' => 'thinkphp@qq.com',
];
$validate = new Validate($rule);
$validate->scene('edit', function($key,$data){
    return 'email'==$key && isset($data['id'])? true : false;
});
$result = $validate->scene('edit')->check($data);

控制器验证

如果你需要在控制器中进行验证,并且继承了\think\Controller的话,可以调用控制器类提供的validate方法进行验证,如下:

$result = $this->validate(
    [
        'name'  => 'thinkphp',
        'email' => 'thinkphp@qq.com',
    ],
    [
        'name'  => 'require|max:25',
        'email'   => 'email',
    ]);
if(true !== $result){
    // 验证失败 输出错误信息
    dump($result);
}

如果定义了验证器类的话,例如:

namespace app\index\validate;

use think\Validate;

class User extends Validate
{
    protected $rule = [
        'name'  =>  'require|max:25',
        'email' =>  'email',
    ];

    protected $message = [
        'name.require'  =>  '用户名必须',
        'email' =>  '邮箱格式错误',
    ];

    protected $scene = [
        'add'   =>  ['name','email'],
        'edit'  =>  ['email'],
    ];
}

控制器中的验证代码可以简化为:

$result = $this->validate($data,'User');
if(true !== $result){
    // 验证失败 输出错误信息
    dump($result);
}

如果要使用场景,可以使用:

$result = $this->validate($data,'User.edit');
if(true !== $result){
    // 验证失败 输出错误信息
    dump($result);
}

在validate方法中还支持做一些前置的操作回调,使用方式如下:

$result = $this->validate($data,'User.edit',[],[$this,'some']);
if(true !== $result){
    // 验证失败 输出错误信息
    dump($result);
}

模型验证

在模型中的验证方式如下:

$User = new User;
$result = $User->validate(
    [
        'name'  => 'require|max:25',
        'email'   => 'email',
    ],
    [
        'name.require' => '名称必须',
        'name.max'     => '名称最多不能超过25个字符',
        'email'        => '邮箱格式错误',
    ]
)->save($data);
if(false === $result){
    // 验证失败 输出错误信息
    dump($User->getError());
}

第二个参数如果不传的话,则采用默认的错误提示信息。

如果使用下面的验证器类的话:

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

    protected $message = [
        'name.require'  =>  '用户名必须',
        'email' =>  '邮箱格式错误',
    ];

    protected $scene = [
        'add'   =>  ['name','email'],
        'edit'  =>  ['email'],
    ];    
}

模型验证代码可以简化为:

$User = new User;
// 调用当前模型对应的User验证器类进行数据验证
$result = $User->validate(true)->save($data);
if(false === $result){
    // 验证失败 输出错误信息
    dump($User->getError());
}

如果需要调用的验证器类和当前的模型名称不一致,则可以使用:

$User = new User;
// 调用Member验证器类进行数据验证
$result = $User->validate('Member')->save($data);
if(false === $result){
    // 验证失败 输出错误信息
    dump($User->getError());
}

同样也可以支持场景验证:

$User = new User;
// 调用Member验证器类进行数据验证
$result = $User->validate('User.edit')->save($data);
if(false === $result){
    // 验证失败 输出错误信息
    dump($User->getError());
}

内置规则

系统内置的验证规则如下:

格式验证类

  • require

验证某个字段必须,例如:

'name'=>'require'
  • number 或者 integer

验证某个字段的值是否为数字(采用filter_var验证),例如:

'num'=>'number'
  • float

验证某个字段的值是否为浮点数字(采用filter_var验证),例如:

'num'=>'float'
  • boolean

验证某个字段的值是否为布尔值(采用filter_var验证),例如:

'num'=>'boolean'
  • email

验证某个字段的值是否为email地址(采用filter_var验证),例如:

'email'=>'email'
  • array

验证某个字段的值是否为数组,例如:

'info'=>'array'
  • accepted

验证某个字段是否为为 yes, on, 或是 1。这在确认"服务条款"是否同意时很有用,例如:

'accept'=>'accepted'
  • date

验证值是否为有效的日期,例如:

'date'=>'date'

会对日期值进行strtotime后进行判断。

  • alpha

验证某个字段的值是否为字母,例如:

'name'=>'alpha'
  • alphaNum

验证某个字段的值是否为字母和数字,例如:

'name'=>'alphaNum'
  • alphaDash

验证某个字段的值是否为字母和数字,下划线_及破折号-,例如:

'name'=>'alphaDash'
  • activeUrl

验证某个字段的值是否为有效的域名或者IP,例如:

'host'=>'activeUrl'
  • url

验证某个字段的值是否为有效的URL地址(采用filter_var验证),例如:

'url'=>'url'
  • ip

验证某个字段的值是否为有效的IP地址(采用filter_var验证),例如:

'ip'=>'ip'

支持验证ipv4和ipv6格式的IP地址。

  • dateFormat:format

验证某个字段的值是否为指定格式的日期,例如:

'create_time'=>'dateFormat:y-m-d'

长度和区间验证类

  • in

验证某个字段的值是否在某个范围,例如:

'num'=>'in:1,2,3'
  • notIn

验证某个字段的值不在某个范围,例如:

'num'=>'notIn:1,2,3'
  • between

验证某个字段的值是否在某个区间,例如:

'num'=>'between:1,10'
  • notBetween

验证某个字段的值不在某个范围,例如:

'num'=>'notBetween:1,10'
  • length:num1,num2

验证某个字段的值的长度是否在某个范围,例如:

'name'=>'length:4,25'

或者指定长度

'name'=>'length:4'

如果验证的数据是数组,则判断数组的长度。

如果验证的数据是File对象,则判断文件的大小。

  • max:number

验证某个字段的值的最大长度,例如:

'name'=>'max:25'

如果验证的数据是数组,则判断数组的长度。

如果验证的数据是File对象,则判断文件的大小。

  • min:number

验证某个字段的值的最小长度,例如:

'name'=>'min:5'

如果验证的数据是数组,则判断数组的长度。

如果验证的数据是File对象,则判断文件的大小。

  • after:日期

验证某个字段的值是否在某个日期之后,例如:

'begin_time' => 'after:2016-3-18',
  • before:日期

验证某个字段的值是否在某个日期之前,例如:

'end_time'   => 'before:2016-10-01',
  • expire:开始时间,结束时间

验证当前操作(注意不是某个值)是否在某个有效日期之内,例如:

'expire_time'   => 'expire:2016-2-1,2016-10-01',
  • allowIp:allow1,allow2,...

验证当前请求的IP是否在某个范围,例如:

'name'   => 'allowIp:114.45.4.55',

该规则可以用于某个后台的访问权限

  • denyIp:allow1,allow2,...

验证当前请求的IP是否禁止访问,例如:

'name'   => 'denyIp:114.45.4.55',

字段比较类

  • confirm

验证某个字段是否和另外一个字段的值一致,例如:

'repassport'=>'require|confirm:passport'
  • different

验证某个字段是否和另外一个字段的值不一致,例如:

'name'=>'require|different:account'
  • egt 或者 >=

验证是否大于等于某个值,例如:

'score'=>'egt:60'
'num'=>'>=:100'
  • gt 或者 >

验证是否大于某个值,例如:

'score'=>'gt:60'
'num'=>'>:100'
  • elt 或者 <=

验证是否小于等于某个值,例如:

'score'=>'elt:100'
'num'=>'<=:100'
  • lt 或者 <

验证是否小于某个值,例如:

'score'=>'lt:100'
'num'=>'<:100'
  • eq 或者 = 或者 same

验证是否等于某个值,例如:

'score'=>'eq:100'
'num'=>'=:100'
'num'=>'same:100'

filter验证

支持使用filter_var进行验证,例如:

'ip'=>'filter:validate_ip'

正则验证

支持直接使用正则验证,例如:

'zip'=>'\d{6}',
// 或者
'zip'=>'regex:\d{6}',

如果你的正则表达式中包含有|符号的话,必须使用数组方式定义。

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

上传验证

  • file

验证是否是一个上传文件

  • image:width,height,type

验证是否是一个图像文件,width height和type都是可选,width和height必须同时定义。

  • fileExt:允许的文件后缀

验证上传文件后缀

  • fileMime:允许的文件类型

验证上传文件类型

  • fileSize:允许的文件字节大小

验证上传文件大小

行为验证

使用行为验证数据,例如:

'data'=>'behavior:\app\index\behavior\Check'

其它验证

  • unique:table,field,except,pk

验证当前请求的字段值是否为唯一的,例如:

// 表示验证name字段的值是否在user表(不包含前缀)中唯一
'name'   => 'unique:user',
// 验证其他字段
'name'   => 'unique:user,account',
// 排除某个主键值
'name'   => 'unique:user,account,10',
// 指定某个主键值排除
'name'   => 'unique:user,account,10,user_id',

如果需要对复杂的条件验证唯一,可以使用下面的方式:

// 多个字段验证唯一验证条件
'name'   => 'unique:user,status^account',
// 复杂验证条件
'name'   => 'unique:user,status=1&account='.$data['account'],
  • requireIf:field,value

验证某个字段的值等于某个值的时候必须,例如:

// 当account的值等于1的时候 password必须
'password'=>'requireIf:account,1'
  • requireWith:field

验证某个字段有值的时候必须,例如:

// 当account有值的时候password字段必须
'password'=>'requireWith:account'

静态调用

如果需要使用内置的规则验证单个数据,可以使用静态调用的方式。

// 日期格式验证
Validate::dateFormat('2016-03-09','Y-m-d'); // true
// 验证是否有效的日期
Validate::is('2016-06-03','date'); // true
// 验证是否有效邮箱地址
Validate::is('thinkphp@qq.com','email'); // true
// 验证是否在某个范围
Validate::in('a',['a','b','c']); // true
// 验证是否大于某个值
Validate::gt(10,8); // true
// 正则验证
Validate::regex(100,'\d+'); // true

静态验证的返回值为布尔值,错误信息需要自己处理。

表单令牌

验证规则支持对表单的令牌验证,首先需要在你的表单里面增加下面隐藏域:

<input type="hidden" name="__token__" value="{$Request.token}" />

或者

{:token()}

然后在你的验证规则中,添加token验证规则即可,例如,如果使用的是验证器的话,可以改为:

    protected $rule = [
        'name'  =>  'require|max:25|token',
        'email' =>  'email',
    ];

如果你的令牌名称不是__token__,则表单需要改为:

<input type="hidden" name="__hash__" value="{$Request.token.__hash__}" />

或者:

{:token('__hash__')}

验证器中需要改为:

    protected $rule = [
        'name'  =>  'require|max:25|token:__hash__',
        'email' =>  'email',
    ];

如果需要自定义令牌生成规则,可以调用Request类的token方法,例如:

namespace app\index\controller;

use think\Controller;

class Index extends Controller
{
    public function index()
    {
        $token = $this->request->token('__token__', 'sha1');
        $this->assign('token', $token);
        return $this->fetch();
    }
}

然后在模板表单中使用:

<input type="hidden" name="__token__" value="{$token}" />

或者不需要在控制器写任何代码,直接在模板中使用:

{:token('__token__', 'sha1')}

参考文档