验证

介绍
验证快速入门
表单请求验证
手动创建验证器
使用经过验证的输入
处理错误消息
可用的验证规则
有条件地添加规则
验证数组
- 验证嵌套数组输入
- 错误消息索引和位置
验证文件
验证密码
自定义验证规则

介绍

Laravel 提供了几种不同的方法来验证应用程序的传入数据。最常见的是使用 validate 方法适用于所有传入的 HTTP 请求。不过，我们还将讨论其他验证方法。

Laravel 包含各种可应用于数据的便捷验证规则，甚至提供验证给定数据库表中的值是否唯一的功能。我们将详细介绍每条验证规则，以便您熟悉 Laravel 的所有验证功能。

验证快速入门

要了解 Laravel 强大的验证功能，让我们看一个完整的示例，该示例验证表单并向用户显示错误消息。通过阅读此高级概述，您将能够很好地了解如何使用 Laravel 验证传入的请求数据：

定义路线

首先，假设我们在 routes/web.php 文件：

1
使用
应用程序\Http\控制器\
后控制器
;
2
3
路线
::
得到
（
‘
/发布/创建
‘
，[
后控制器
::
班级
,
‘
创造
‘
]);
4
路线
::
邮政
（
‘
/邮政
‘
，[
后控制器
::
班级
,
‘
店铺
‘
]);
使用 App\Http\Controllers\PostController；路由::get('/post/create'，[PostController::class，'create']);路由::post('/post'，[PostController::class，'store']);

这 GET 路线将显示一个表单，供用户创建新的博客文章，而 POST 路线将把新的博客文章存储在数据库中。

创建控制器

接下来，让我们看一个处理这些路由传入请求的简单控制器。我们将 store 方法目前为空：

1
2
3
命名空间
应用程序\Http\控制器；
4
5
使用
照亮\Http\
重定向响应
;
6
使用
照亮\Http\
要求
;
7
使用
照亮\查看\
看法
;
8
9
班级

后控制器

延伸

控制器
10
{
11

/**
12
* 显示创建新博客文章的表单。
13

*/
14

民众

功能

创造
（）
:

看法
15
{
16

返回

看法
（
‘
帖子创建
‘
（英文）：
17
}
18
19

/**
20
* 存储新的博客文章。
21

*/
22

民众

功能

店铺
（
要求

$请求
）
:

重定向响应
23
{
24

//
验证并存储博客文章...
25
26

$post

=

/**
...
*/
27
28

返回

到路线
（
‘
演出后
‘
,

[
‘
邮政
‘

=>

$
邮政
->id
]);
29
}
30
}
 $post->id]); } }

编写验证逻辑

现在我们准备填写我们的 store 方法，并添加逻辑来验证新博客文章。为此，我们将使用 validate 方法提供 Illuminate\Http\Request 对象。如果验证规则通过，您的代码将继续正常执行；但是，如果验证失败，则 Illuminate\Validation\ValidationException 将抛出异常并自动将正确的错误响应发送回用户。

如果在传统 HTTP 请求期间验证失败，则会生成对先前 URL 的重定向响应。如果传入请求是 XHR 请求，则包含验证错误消息的 JSON 响应将被退回。

为了更好地理解 validate 方法，让我们回到 store 方法：

1
/**
2
* 存储新的博客文章。
3

*/
4
民众

功能

店铺
（
要求

$请求
）
:

重定向响应
5
{
6

$已验证

=

$请求
->
证实
（[
7

‘
标题
‘

=>

‘
必填|唯一：帖子|最大值：255
‘
,
8

‘
身体
‘

=>

‘
必需的
‘
,
9
]);
10
11

//
该博客文章有效...
12
13

返回

重定向
（
‘
/帖子
‘
（英文）：
14
}
/** * 存储新的博客文章。 */ public function store(Request $request): RedirectResponse { $validated = $request->validate([ 'title' => 'required|unique:posts|max:255', 'body' => 'required', ]); // 博客文章有效... return redirect('/posts'); }

如你所见，验证规则被传递到 validate 方法。不用担心 - 所有可用的验证规则都是有记录的。同样，如果验证失败，将自动生成正确的响应。如果验证通过，我们的控制器将继续正常执行。

或者，验证规则也可以指定为规则数组，而不是单个 | 分隔字符串：

1
$已验证数据

=

$请求
->
证实
（[
2

‘
标题
‘

=>
[
‘
必需的
‘
,
‘
唯一：帖子
‘
,
‘
最大：255
‘
]，
3

‘
身体
‘

=>
[
‘
必需的
‘
]，
4
]);
$validatedData = $request->validate([ 'title' => ['required', 'unique:posts', 'max:255'], 'body' => ['required'], ]);

此外，您还可以使用 validateWithBag 方法来验证请求并将任何错误消息存储在命名错误包 :

1
$已验证数据

=

$请求
->
验证方法
（
‘
邮政
‘
，[
2

‘
标题
‘

=>
[
‘
必需的
‘
,
‘
唯一：帖子
‘
,
‘
最大：255
‘
]，
3

‘
身体
‘

=>
[
‘
必需的
‘
]，
4
]);
$validatedData = $request->validateWithBag('post', [ 'title' => ['必填', 'unique:posts', 'max:255'], 'body' => ['必填'], ]);

第一次验证失败时停止

有时您可能希望在第一次验证失败后停止对属性运行验证规则。为此，请分配 bail 规则到属性：

1
$请求
->
证实
（[
2

‘
标题
‘

=>

‘
保释|必填|唯一：帖子|最大：255
‘
,
3

‘
身体
‘

=>

‘
必需的
‘
,
4
]);
$request->validate([ 'title' => '保释|required|unique:posts|max:255', 'body' => 'required', ]);

在此示例中，如果 unique 规则 title 属性失败， max 不会检查规则。规则将按照其分配的顺序进行验证。

关于嵌套属性的注释

如果传入的 HTTP 请求包含“嵌套”字段数据，则您可以使用“点”语法在验证规则中指定这些字段：

1
$请求
->
证实
（[
2

‘
标题
‘

=>

‘
必填|唯一：帖子|最大值：255
‘
,
3

‘
作者姓名
‘

=>

‘
必需的
‘
,
4

‘
作者.描述
‘

=>

‘
必需的
‘
,
5
]);
$request->validate([ 'title' => '必填|unique:posts|max:255', 'author.name' => '必填', 'author.description' => '必填', ]);

另一方面，如果您的字段名称包含文字句点，则可以通过使用反斜杠转义句点来明确防止其被解释为“点”语法：

1
$请求
->
证实
（[
2

‘
标题
‘

=>

‘
必填|唯一：帖子|最大值：255
‘
,
3

‘
v1\.0
‘

=>

‘
必需的
‘
,
4
]);
$request->validate([ 'title' => '必填|唯一：帖子|最大值：255', 'v1\.0' => '必填', ]);

显示验证错误

那么，如果传入的请求字段未通过给定的验证规则怎么办？如前所述，Laravel 会自动将用户重定向回其之前的位置。此外，所有验证错误和请求输入将自动闪现到会话中。

一个 $errors 变量由你应用程序的所有视图共享 Illuminate\View\Middleware\ShareErrorsFromSession 中间件，由 web 中间件组。当应用此中间件时 $errors 变量将始终在您的视图中可用，让您可以方便地假设 $errors 变量始终是定义的并且可以安全地使用。 $errors 变量将是 Illuminate\Support\MessageBag . 有关使用此对象的更多信息，查看其文档。

因此，在我们的示例中，用户将被重定向到我们的控制器的 create 方法，允许我们在视图中显示错误消息：

1

/resources/views/post/create.blade.php
-->
2
3
<
h1
>
创建帖子
</
h1
>
4
5
@如果
（
$错误
->
任何
（））
6

<
div

班级
=
“
警报 警报危险
“
>
7

<
乌尔
>
8

@foreach
（
$错误
->
全部
（）
作为

$错误
）
9

<
那
>{{

$错误

}}}
那
>
10

@endforeach
11

</
乌尔
>
12

</
div
>
13
@endif
14
15

创建帖子表单
-->
 创建帖子
 @if ($errors->any())   @foreach ($errors->all() as $error) {{ $error }>
 @endforeach 
 
 @endif

自定义错误消息

Laravel 的内置验证规则各自都有一个错误消息，位于应用程序的 lang/en/validation.php 文件。如果您的应用程序没有 lang 目录，你可以指示 Laravel 使用以下命令创建它 lang:publish 工匠指挥。

在 lang/en/validation.php 文件中，您将找到每个验证规则的翻译条目。您可以根据应用程序的需要随意更改或修改这些消息。

此外，您还可以将此文件复制到另一个语言目录，以将消息翻译成您应用程序的语言。要了解有关 Laravel 本地化的更多信息，请查看完整的本地化文档。

默认情况下，Laravel 应用程序骨架不包含 lang 目录。如果你想自定义 Laravel 的语言文件，你可以通过 lang:publish 工匠指挥。

XHR 请求和验证

在此示例中，我们使用传统表单将数据发送到应用程序。但是，许多应用程序从 JavaScript 驱动的前端接收 XHR 请求。使用 validate 方法，Laravel 将不会生成重定向响应。相反，Laravel 会生成一个包含所有验证错误的 JSON 响应。此 JSON 响应将与 422 HTTP 状态代码一起发送。

这 `@error` 指示

您可以使用 @error 刀刃指令来快速确定给定属性是否存在验证错误消息。在 @error 指令，您可以回应 $message 变量来显示错误消息：

1

/resources/views/post/create.blade.php
-->
2
3
<
标签

为了
=
“
标题
“
>
帖子标题
</
标签
>
4
5
<
输入
6

ID
=
“
标题
“
7

类型
=
“
文本
“
8

姓名
=
“
标题
“
9

班级
=
“
@错误
（
‘
标题
‘
) 无效
@enderror
“
10
/>
11
12
@错误
（
‘
标题
‘
）
13

<
div

班级
=
“
警报 警报危险
“
>{{

$消息

}}}
div
>
14
@enderror
 帖子标题  @error('title') {{ $message }}}div> @enderror

如果你正在使用命名错误包，你可以将错误包的名称作为第二个参数传递给 @error 指示：

1
<
输入

...

班级
=
“
@错误
（
‘
标题
‘
,
‘
邮政
‘
) 无效
@enderror
“
>

重新填充表格

当 Laravel 因验证错误而生成重定向响应时，框架将自动将所有请求的输入闪现到会话中。这样做是为了您可以在下一次请求期间方便地访问输入并重新填充用户尝试提交的表单。

要从上一个请求中检索闪存的输入，请调用 old 实例上的方法 Illuminate\Http\Request 。这 old 方法将从会议 :

1
$title

=

$请求
->
老的
（
‘
标题
‘
（英文）：
$title = $request->old('标题');

Laravel 还提供了全局 old 帮助器。如果您在 Blade 模板，使用起来更方便 old 帮助程序重新填充表单。如果给定字段不存在旧输入， null 将会被退回：

1
<
输入

类型
=
“
文本
“

姓名
=
“
标题
“

价值
=
“
{{

老的
（
‘
标题
‘
）

}}
“
>

关于可选字段的说明

默认情况下，Laravel 包含 TrimStrings 和 ConvertEmptyStringsToNull 应用程序全局中间件堆栈中的中间件。因此，您通常需要将“可选”请求字段标记为 nullable 如果你不想让验证者考虑 null 值无效。例如：

1
$请求
->
证实
（[
2

‘
标题
‘

=>

‘
必填|唯一：帖子|最大值：255
‘
,
3

‘
身体
‘

=>

‘
必需的
‘
,
4

‘
发布时间
‘

=>

‘
可空|日期
‘
,
5
]);
$request->validate([ 'title' => '必填|唯一：帖子|最大值：255', 'body' => '必填', 'publish_at' => '可为空|日期', ]);

在此示例中，我们指定 publish_at 字段可以是 null 或有效的日期表示。如果 nullable 修饰符未添加到规则定义中，验证器将考虑 null 无效日期。

验证错误响应格式

当你的应用程序抛出一个 Illuminate\Validation\ValidationException 异常并且传入的 HTTP 请求需要 JSON 响应，Laravel 将自动格式化错误消息并返回 422 Unprocessable Entity HTTP 响应。

下面，您可以查看验证错误的 JSON 响应格式示例。请注意，嵌套错误键被展平为“点”符号格式：

1
{
2

“信息”
:
“
球队名称必须是字符串。（以及另外 4 个错误）
“
,
3

“错误”
：{
4

“团队名称”
：[
5

“
球队名称必须是字符串。
“
,
6

“
队伍名称必须至少有1个字符。
“
7
]，
8

“授权.角色”
：[
9

“
所选的 authorization.role 无效。
“
10
]，
11

“用户.0.电子邮件”
：[
12

“
users.0.email 字段是必填的。
“
13
]，
14

“用户.2.电子邮件”
：[
15

“
users.2.email 必须是有效的电子邮件地址。
“
16
]
17
}
18
}
{ “message”：“团队名称必须是字符串。（以及另外 4 个错误）”，“errors”：{“team_name”：[“团队名称必须是字符串。”，“团队名称必须至少包含 1 个字符。”]，“authorization.role”：[“所选的 authorization.role 无效。”]，“users.0.email”：[“users.0.email 字段是必填的。”]，“users.2.email”：[“users.2.email 必须是有效的电子邮件地址。”] } }

表单请求验证

创建表单请求

对于更复杂的验证场景，您可能希望创建“表单请求”。表单请求是封装了其自身验证和授权逻辑的自定义请求类。要创建表单请求类，您可以使用 make:request Artisan CLI 命令：

1
php
工匠

制作：请求

商店发布请求
php artisan make：请求 StorePostRequest

生成的表单请求类将放置在 app/Http/Requests 目录。如果此目录不存在，则运行 make:request 命令。Laravel 生成的每个表单请求都有两种方法： authorize 和 rules 。

你可能已经猜到了， authorize 方法负责确定当前经过身份验证的用户是否可以执行请求所代表的操作，而 rules 方法返回应应用于请求数据的验证规则：

1
/**
2
* 获取适用于请求的验证规则。
3
*
4
*
@返回

大批
<
细绳
, \Illuminate\Contracts\Validation\ValidationRule|数组<混合>|字符串>
5

*/
6
民众

功能

规则
（）
:

大批
7
{
8

返回
[
9

‘
标题
‘

=>

‘
必填|唯一：帖子|最大值：255
‘
,
10

‘
身体
‘

=>

‘
必需的
‘
,
11
]；
12
}
/** * 获取适用于请求的验证规则。 * * @return array|string> */ public function rules(): array { return [ 'title' => 'required|unique:posts|max:255', 'body' => 'required', ]; }

您可以在 rules 方法签名。它们将通过 Laravel 自动解析服务容器。

那么，验证规则是如何评估的呢？您需要做的就是在控制器方法上键入请求提示。传入的表单请求在调用控制器方法之前进行验证，这意味着您不需要用任何验证逻辑来弄乱控制器：

1
/**
2
* 存储新的博客文章。
3

*/
4
民众

功能

店铺
（
商店发布请求

$请求
）
:

重定向响应
5
{
6

//
传入请求有效...
7
8

//
检索已验证的输入数据...
9

$已验证

=

$请求
->
已验证
（）；
10
11

//
检索部分已验证的输入数据...
12

$已验证

=

$请求
->
安全的
（）
->
仅有的
（[
‘
姓名
‘
,
‘
电子邮件
‘
]);
13

$已验证

=

$请求
->
安全的
（）
->
除了
（[
‘
姓名
‘
,
‘
电子邮件
‘
]);
14
15

//
存储博客文章...
16
17

返回

重定向
（
‘
/帖子
‘
（英文）：
18
}
/** * 存储新的博客文章。 */ public function store(StorePostRequest $request): RedirectResponse { // 传入请求有效... // 检索经过验证的输入数据... $validated = $request->validated(); // 检索部分经过验证的输入数据... $validated = $request->safe()->only(['name', 'email']); $validated = $request->safe()->except(['name', 'email']); // 存储博客文章... return redirect('/posts'); }

如果验证失败，将生成重定向响应以将用户送回其之前的位置。错误还将闪现到会话中，以便显示。如果请求是 XHR 请求，则将向用户返回带有 422 状态代码的 HTTP 响应，其中包括验证错误的 JSON 表示。

需要向 Inertia 驱动的 Laravel 前端添加实时表单请求验证？请查看 Laravel 预知。

执行其他验证

有时，您需要在初始验证完成后执行其他验证。您可以使用表单请求的 after 方法。

这 after 方法应返回一个可调用函数或闭包数组，这些函数或闭包将在验证完成后调用。给定的可调用函数将收到一个 Illuminate\Validation\Validator 例如，允许您在必要时引发其他错误消息：

1
使用
照亮\验证\
验证者
;
2
3
/**
4
* 获取请求的“之后”验证可调用函数。
5

*/
6
民众

功能

后
（）
:

大批
7
{
8

返回
[
9

功能

（
验证者

$验证器
）
{
10

如果
（
$this
->
其它无效
（））{
11

$验证器
->
错误
（）
->
添加
（
12

‘
场地
‘
,
13

‘
此字段有问题！
‘
14
（英文）：
15
}
16
}
17
]；
18
}
使用 Illuminate\Validation\Validator; /** * 获取请求的“之后”验证可调用函数。 */ public function after(): array { return [ function (Validator $validator) { if ($this->somethingElseIsInvalid()) { $validator->errors()->add( 'field', '此字段有问题！' ); } } ]; }

如上所述， after 方法也可能包含可调用类。 __invoke 这些类的方法将收到 Illuminate\Validation\Validator 实例：

1
使用
应用程序\验证\
确认发货时间
;
2
使用
应用程序\验证\
验证用户状态
;
3
使用
照亮\验证\
验证者
;
4
5
/**
6
* 获取请求的“之后”验证可调用函数。
7

*/
8
民众

功能

后
（）
:

大批
9
{
10

返回
[
11

新的

验证用户状态
,
12

新的

确认发货时间
,
13

功能

（
验证者

$验证器
）
{
14

//
15
}
16
]；
17
}
使用 App\Validation\ValidateShippingTime；使用 App\Validation\ValidateUserStatus；使用 Illuminate\Validation\Validator；/** * 获取请求的“之后”验证可调用函数。*/ public function after(): array { return [ new ValidateUserStatus, new ValidateShippingTime, function (Validator $validator) { // } ]; }

第一次验证失败时停止

通过添加 stopOnFirstFailure 属性到您的请求类，您可以通知验证器，一旦发生单个验证失败，它应该停止验证所有属性：

1
/**
2
* 表示验证器是否应在第一个规则失败时停止。
3
*
4
*
@我们的

布尔值
5

*/
6
受保护

$stopOnFirstFailure

=

真的
;
/** * 指示验证器是否应在第一个规则失败时停止。 * * @var bool */ protected $stopOnFirstFailure = true;

自定义重定向位置

当表单请求验证失败时，将生成重定向响应以将用户送回其之前的位置。但是，您可以自由自定义此行为。为此，请定义一个 $redirect 您的表格请求中的属性：

1
/**
2
* 如果验证失败，用户应该被重定向到的 URI。
3
*
4
*
@我们的

细绳
5

*/
6
受保护

$重定向

=

‘
/仪表板
‘
;
/** * 如果验证失败，用户应该重定向到的 URI。 * * @var string */ protected $redirect = '/dashboard';

或者，如果你想将用户重定向到命名路线，你可以定义一个 $redirectRoute 属性：

1
/**
2
* 如果验证失败，用户应该被重定向到的路线。
3
*
4
*
@我们的

细绳
5

*/
6
受保护

$redirectRoute

=

‘
仪表板
‘
;
/** * 如果验证失败，用户应该重定向到的路线。 * * @var string */ protected $redirectRoute = 'dashboard';

授权表单请求

表单请求类还包含一个 authorize 方法。在此方法中，您可以确定经过身份验证的用户是否确实有权更新给定的资源。例如，您可以确定用户是否真正拥有他们试图更新的博客评论。最有可能的是，您将与您的授权门和政策在此方法中：

1
使用
应用程序\模型\
评论
;
2
3
/**
4
* 确定用户是否有权提出此请求。
5

*/
6
民众

功能

授权
（）
:

布尔值
7
{
8

评论

=

评论
::
寻找
（
$this
->
路线
（
‘
评论
‘
））；
9
10

返回

评论

&&

$this
->
用户
（）
->
能
（
‘
更新
‘
,
评论
（英文）：
11
}
使用 App\Models\Comment; /** * 确定用户是否有权发出此请求。 */ public function authorize(): bool { $comment = Comment::find($this->route('comment')); return $comment && $this->user()->can('update', $comment); }

由于所有表单请求都扩展了基本 Laravel 请求类，因此我们可以使用 user 方法访问当前已验证的用户。另外，请注意对 route 方法。此方法授予您访问所调用路由上定义的 URI 参数的权限，例如 {comment} 下例中的参数：

1
路线
::
邮政
（
‘
/评论/{评论}
‘
（英文）：
路线::post（'/评论/{评论}'）;

因此，如果你的应用程序利用路线模型绑定，通过将解析模型作为请求的属性进行访问，您的代码可能会变得更加简洁：

1
返回

$this
->
用户
（）
->
能
（
‘
更新
‘
,
$this
->评论
（英文）：
返回 $this->user()->can('update', $this->comment);

如果 authorize 方法返回 false ，将自动返回具有 403 状态代码的 HTTP 响应，并且您的控制器方法将不会执行。

如果您计划在应用程序的另一部分处理请求的授权逻辑，则可以删除 authorize 方法完全，或者简单地返回 true :

1
/**
2
* 确定用户是否有权提出此请求。
3

*/
4
民众

功能

授权
（）
:

布尔值
5
{
6

返回

真的
;
7
}
/** * 确定用户是否有权发出此请求。 */ public function authorize(): bool { return true; }

您可以在 authorize 方法签名。它们将通过 Laravel 自动解析服务容器。

自定义错误消息

您可以通过覆盖以下代码来自定义表单请求使用的错误消息： messages 方法。此方法应返回属性/规则对的数组及其相应的错误消息：

1
/**
2
* 获取定义的验证规则的错误消息。
3
*
4
*
@返回

大批
<
细绳
, 字符串>
5

*/
6
民众

功能

消息
（）
:

大批
7
{
8

返回
[
9

‘
标题.必填
‘

=>

‘
需要标题
‘
,
10

‘
body.required
‘

=>

‘
需要留言
‘
,
11
]；
12
}
/** * 获取定义的验证规则的错误消息。 * * @return array */ public function messages(): array { return [ 'title.required' => '需要标题', 'body.required' => '需要消息', ]; }

自定义验证属性

Laravel 的许多内置验证规则错误消息都包含 :attribute 占位符。如果您想要 :attribute 验证消息的占位符将被替换为自定义属性名称，你可以通过覆盖来指定自定义名称 attributes 方法。此方法应返回属性/名称对的数组：

1
/**
2
* 获取验证器错误的自定义属性。
3
*
4
*
@返回

大批
<
细绳
, 字符串>
5

*/
6
民众

功能

属性
（）
:

大批
7
{
8

返回
[
9

‘
电子邮件
‘

=>

‘
电子邮件
‘
,
10
]；
11
}
/** * 获取验证器错误的自定义属性。 * * @return array */ public function attribute(): array { return [ 'email' => '电子邮件地址', ]; }

准备验证输入

如果您需要在应用验证规则之前准备或清理请求中的任何数据，则可以使用 prepareForValidation 方法：

1
使用
照亮\支持\
力量
;
2
3
/**
4
* 准备数据以供验证。
5

*/
6
受保护

功能

准备验证
（）
:

空白
7
{
8

$this
->
合并
（[
9

‘
蛞蝓
‘

=>

力量
::
蛞蝓
（
$this
-> 蛞蝓
),
10
]);
11
}
使用 Illuminate\Support\Str; /** * 准备数据以进行验证。 */ protected function prepareForValidation(): void { $this->merge([ 'slug' => Str::slug($this->slug), ]); }

同样，如果您需要在验证完成后规范化任何请求数据，则可以使用 passedValidation 方法：

1
/**
2
* 处理通过的验证尝试。
3

*/
4
受保护

功能

已通过验证
（）
:

空白
5
{
6

$this
->
代替
（[
‘
姓名
‘

=>

‘
泰勒
‘
]);
7
}
/** * 处理已通过的验证尝试。 */ protected function passingValidation(): void { $this->replace(['name' => 'Taylor']); }

手动创建验证器

如果你不想使用 validate 方法，你可以使用以下方法手动创建验证器实例： Validator 正面。这 make 外观上的方法生成一个新的验证器实例：

1
2
3
命名空间
应用程序\Http\控制器；
4
5
使用
照亮\Http\
重定向响应
;
6
使用
照亮\Http\
要求
;
7
使用
照亮\支撑\外墙\
验证者
;
8
9
班级

后控制器

延伸

控制器
10
{
11

/**
12
* 存储新的博客文章。
13

*/
14

民众

功能

店铺
（
要求

$请求
）
:

重定向响应
15
{
16

$验证器

=

验证者
::
制作
（
$请求
->
全部
（），[
17

‘
标题
‘

=>

‘
必填|唯一：帖子|最大值：255
‘
,
18

‘
身体
‘

=>

‘
必需的
‘
,
19
]);
20
21

如果
（
$验证器
->
失败
（））{
22

返回

重定向
（
‘
/发布/创建
‘
）
23

->
带有错误
（
$验证器
）
24

->
带输入
（）；
25
}
26
27

//
检索已验证的输入...
28

$已验证

=

$验证器
->
已验证
（）；
29
30

//
检索已验证输入的一部分...
31

$已验证

=

$验证器
->
安全的
（）
->
仅有的
（[
‘
姓名
‘
,
‘
电子邮件
‘
]);
32

$已验证

=

$验证器
->
安全的
（）
->
除了
（[
‘
姓名
‘
,
‘
电子邮件
‘
]);
33
34

//
存储博客文章...
35
36

返回

重定向
（
‘
/帖子
‘
（英文）：
37
}
38
}
all(), [ 'title' => 'required|unique:posts|max:255', 'body' => 'required', ]); if ($validator->fails()) { return redirect('/post/create') ->withErrors($validator) ->withInput(); } // 检索已验证的输入... $validated = $validator->validated(); // 检索部分已验证的输入... $validated = $validator->safe()->only(['name', 'email']); $validated = $validator->safe()->except(['name', 'email']); // 存储博客文章... return redirect('/posts'); } }

传递给 make 方法是验证的数据。第二个参数是应该应用于数据的验证规则的数组。

确定请求验证是否失败后，您可以使用 withErrors 方法将错误消息闪现到会话中。使用此方法时， $errors 变量将在重定向后自动与您的视图共享，使您可以轻松地将它们显示回用户。 withErrors 方法接受一个验证器，一个 MessageBag 或 PHP array 。

第一次验证失败时停止

这 stopOnFirstFailure 方法将通知验证器，一旦发生单个验证失败，它应该停止验证所有属性：

1
如果
（
$验证器
->
第一次失败时停止
（）
->
失败
（））{
2

//
...
3
}
如果 ($validator->stopOnFirstFailure()->fails()) { // ... }

自动重定向

如果你想手动创建验证器实例，但仍利用 HTTP 请求提供的自动重定向 validate 方法，您可以调用 validate 方法。如果验证失败，用户将自动重定向，或者在 XHR 请求的情况下，将返回 JSON 响应 :

1
验证者
::
制作
（
$请求
->
全部
（），[
2

‘
标题
‘

=>

‘
必填|唯一：帖子|最大值：255
‘
,
3

‘
身体
‘

=>

‘
必需的
‘
,
4
]）
->
证实
（）；
验证器::make($request->all(), [ 'title' => 'required|unique:posts|max:255', 'body' => 'required', ])->validate();

您可以使用 validateWithBag 方法将错误消息存储在命名错误包如果验证失败：

1
验证者
::
制作
（
$请求
->
全部
（），[
2

‘
标题
‘

=>

‘
必填|唯一：帖子|最大值：255
‘
,
3

‘
身体
‘

=>

‘
必需的
‘
,
4
]）
->
验证方法
（
‘
邮政
‘
（英文）：
验证器::make($request->all(), [ 'title' => 'required|unique:posts|max:255', 'body' => 'required', ])->validateWithBag('post');

命名错误包

如果一页上有多个表单，您可能希望将表单命名为 MessageBag 包含验证错误，允许您检索特定表单的错误消息。为此，请将名称作为第二个参数传递给 withErrors :

1
返回

重定向
（
‘
/登记
‘
）
->
带有错误
（
$验证器
,
‘
登录
‘
（英文）：
返回重定向（'/register'）->withErrors（$validator，'login'）;

然后您可以访问命名的 MessageBag 实例来自 $errors 多变的：

1
{{

$错误
->登录->
第一的
（
‘
电子邮件
‘
）
}}
{{ $errors->login->first('email') }}

自定义错误消息

如果需要，您可以提供验证器实例应使用的自定义错误消息，而不是 Laravel 提供的默认错误消息。有几种方法可以指定自定义消息。首先，您可以将自定义消息作为第三个参数传递给 Validator::make 方法：

1
$验证器

=

验证者
::
制作
（
$输入
,
$规则
,
$消息

=
[
2

‘
必需的
‘

=>

‘
:attribute 字段是必需的。
‘
,
3
]);
$validator = Validator::make($input, $rules, $messages = [ 'required' => ':attribute 字段是必填的。', ]);

在此示例中， :attribute 占位符将被替换为验证字段的实际名称。您还可以在验证消息中使用其他占位符。例如：

1
$消息

=
[
2

‘
相同的
‘

=>

‘
:attribute 和 :other 必须匹配。
‘
,
3

‘
尺寸
‘

=>

‘
:attribute 必须正好是 :size。
‘
,
4

‘
之间
‘

=>

‘
:attribute 值 :input 不在 :min - :max 之间。
‘
,
5

‘
在
‘

=>

‘
:attribute 必须是下列类型之一：:values
‘
,
6
]；
$messages = [ 'same' => ':attribute 与 :other 必须匹配。', 'size' => ':attribute 必须与 :size 完全一致。', 'between' => ':attribute 值 :input 不在 :min - :max 之间。', 'in' => ':attribute 必须是下列类型之一：:values', ];

为给定属性指定自定义消息

有时您可能希望仅为特定属性指定自定义错误消息。您可以使用“点”符号来实现。首先指定属性的名称，然后指定规则：

1
$消息

=
[
2

‘
email.必填
‘

=>

‘
我们需要知道您的电子邮件地址！
‘
,
3
]；
$messages = [ 'email.required' => '我们需要知道您的电子邮件地址！', ];

指定自定义属性值

Laravel 的许多内置错误消息都包含 :attribute 占位符，用于替换验证字段或属性的名称。要自定义用于替换特定字段的占位符的值，您可以将自定义属性数组作为第四个参数传递给 Validator::make 方法：

1
$验证器

=

验证者
::
制作
（
$输入
,
$规则
,
$消息
，[
2

‘
电子邮件
‘

=>

‘
电子邮件
‘
,
3
]);
$validator = Validator::make($input, $rules, $messages, [ 'email' => '电子邮件地址', ]);

执行其他验证

有时，您需要在初始验证完成后执行其他验证。您可以使用验证器的 after 方法。这 after 方法接受一个闭包或一个可调用函数数组，这些可调用函数将在验证完成后被调用。给定的可调用函数将收到一个 Illuminate\Validation\Validator 例如，允许您在必要时引发其他错误消息：

1
使用
照亮\支撑\外墙\
验证者
;
2
3
$验证器

=

验证者
::
制作
（
/*
...
*/
（英文）：
4
5
$验证器
->
后
（
功能

（
$验证器
）
{
6

如果
（
$this
->
其它无效
（））{
7

$验证器
->
错误
（）
->
添加
（
8

‘
场地
‘
,
‘
此字段有问题！
‘
9
（英文）：
10
}
11
});
12
13
如果
（
$验证器
->
失败
（））{
14

//
...
15
}
使用 Illuminate\Support\Facades\Validator；$validator = Validator::make(/* ... */); $validator->after(function ($validator) { if ($this->somethingElseIsInvalid()) { $validator->errors()->add( 'field', '该字段有问题！' ); } }); if ($validator->fails()) { // ... }

如上所述， after 方法还接受一个可调用数组，如果你的“验证后”逻辑封装在可调用类中，这将特别方便，它将接收一个 Illuminate\Validation\Validator 例如通过他们的 __invoke 方法：

1
使用
应用程序\验证\
确认发货时间
;
2
使用
应用程序\验证\
验证用户状态
;
3
4
$验证器
->
后
（[
5

新的

验证用户状态
,
6

新的

确认发货时间
,
7

功能

（
$验证器
）
{
8

//
...
9
}，
10
]);
使用 App\Validation\ValidateShippingTime; 使用 App\Validation\ValidateUserStatus; $validator->after([ new ValidateUserStatus, new ValidateShippingTime, 函数 ($validator) { // ... }, ]);

使用经过验证的输入

使用表单请求或手动创建的验证器实例验证传入的请求数据后，您可能希望检索实际经过验证的传入请求数据。这可以通过多种方式实现。首先，您可以调用 validated 方法应用于表单请求或验证器实例。此方法返回已验证的数据数组：

1
$已验证

=

$请求
->
已验证
（）；
2
3
$已验证

=

$验证器
->
已验证
（）；
$已验证 = $请求->已验证(); $已验证 = $验证器->已验证();

或者，您也可以致电 safe 方法。此方法返回 Illuminate\Support\ValidatedInput .此对象公开 only , except ，和 all 检索验证数据的子集或整个验证数据数组的方法：

1
$已验证

=

$请求
->
安全的
（）
->
仅有的
（[
‘
姓名
‘
,
‘
电子邮件
‘
]);
2
3
$已验证

=

$请求
->
安全的
（）
->
除了
（[
‘
姓名
‘
,
‘
电子邮件
‘
]);
4
5
$已验证

=

$请求
->
安全的
（）
->
全部
（）；
$validated = $request->safe()->only(['name', 'email']); $validated = $request->safe()->except(['name', 'email']); $validated = $request->safe()->all();

此外， Illuminate\Support\ValidatedInput 实例可以像数组一样进行迭代和访问：

1
//
已验证的数据可能会被迭代...
2
foreach
（
$请求
->
安全的
（）
作为

$键

=>

$值
）{
3

//
...
4
}
5
6
//
已验证的数据可以作为数组访问......
7
$已验证

=

$请求
->
安全的
（）；
8
9
$电子邮件

=

$已验证
[
‘
电子邮件
‘
]；
// 可以迭代已验证的数据... foreach ($request->safe() as $key => $value) { // ... } // 可以作为数组访问已验证的数据... $validated = $request->safe(); $email = $validated['email'];

如果你想向验证数据添加其他字段，你可以调用 merge 方法：

1
$已验证

=

$请求
->
安全的
（）
->
合并
（[
‘
姓名
‘

=>

‘
泰勒·奥特威尔
‘
]);
$validated = $request->safe()->merge(['name' => '泰勒·奥特韦尔']);

如果你想检索经过验证的数据作为收藏例如，你可以调用 collect 方法：

1
$集合

=

$请求
->
安全的
（）
->
收集
（）；
$collection = $request->safe()->collect();

处理错误消息

调用 errors 方法 Validator 例如，您将收到 Illuminate\Support\MessageBag 实例，它有多种方便的方法来处理错误消息。 $errors 自动提供给所有视图的变量也是 MessageBag 班级。

检索字段的第一条错误消息

要检索给定字段的第一个错误消息，请使用 first 方法：

1
$错误

=

$验证器
->
错误
（）；
2
3
回声

$错误
->
第一的
（
‘
电子邮件
‘
（英文）：
$errors = $validator->errors(); echo $errors->first('email');

检索字段的所有错误消息

如果需要检索给定字段的所有消息的数组，请使用 get 方法：

1
foreach
（
$错误
->
得到
（
‘
电子邮件
‘
）
作为

$消息
）{
2

//
...
3
}
foreach ($errors->get('email') 作为 $message) { // ... }

如果你正在验证一个数组表单字段，你可以使用 * 特点：

1
foreach
（
$错误
->
得到
（
‘
附件。*
‘
）
作为

$消息
）{
2

//
...
3
}
foreach ($errors->get('attachments.*') 作为 $message) { // ... }

检索所有字段的所有错误消息

要检索所有字段的所有消息的数组，请使用 all 方法：

1
foreach
（
$错误
->
全部
（）
作为

$消息
）{
2

//
...
3
}
foreach ($errors->all() 作为 $message) { // ... }

确定字段是否存在消息

这 has 方法可用于确定给定字段是否存在任何错误消息：

1
如果
（
$错误
->
有
（
‘
电子邮件
‘
））{
2

//
...
3
}
如果 ($errors->has('email')) { // ... }

在语言文件中指定自定义消息

在 lang/en/validation.php 文件中，您将找到每个验证规则的翻译条目。您可以根据应用程序的需要随意更改或修改这些消息。

默认情况下，Laravel 应用程序骨架不包含 lang 目录。如果你想自定义 Laravel 的语言文件，你可以通过 lang:publish 工匠指挥。

特定属性的自定义消息

您可以在应用程序的验证语言文件中自定义用于指定属性和规则组合的错误消息。为此，请将您的消息自定义添加到 custom 你的应用程序的数组 lang/xx/validation.php 语言文件：

1
‘
风俗
‘

=>
[
2

‘
电子邮件
‘

=>
[
3

‘
必需的
‘

=>

‘
我们需要知道您的电子邮件地址！
‘
,
4

‘
最大限度
‘

=>

‘
您的电子邮件地址太长！
‘
5
]，
6
]，
'custom' => [ 'email' => [ 'required' => '我们需要知道您的电子邮件地址！', 'max' => '您的电子邮件地址太长！' ], ],

在语言文件中指定属性

Laravel 的许多内置错误消息都包含 :attribute 占位符，替换为验证中的字段或属性的名称。如果您希望 :attribute 验证消息的一部分将被替换为自定义值，您可以在 attributes 你的数组 lang/xx/validation.php 语言文件：

1
‘
属性
‘

=>
[
2

‘
电子邮件
‘

=>

‘
电子邮件
‘
,
3
]，
'attributes' => [ 'email' => '电子邮件地址', ],

默认情况下，Laravel 应用程序骨架不包含 lang 目录。如果你想自定义 Laravel 的语言文件，你可以通过 lang:publish 工匠指挥。

在语言文件中指定值

Laravel 的一些内置验证规则错误消息包含 :value 占位符，替换为请求属性的当前值。但是，有时您可能需要 :value 验证消息的一部分将被替换为值的自定义表示。例如，考虑以下规则，该规则指定在以下情况下需要输入信用卡号： payment_type 值为 cc :

1
验证者
::
制作
（
$请求
->
全部
（），[
2

‘
信用卡号码
‘

=>

‘
required_if:付款类型，cc
‘
3
]);
验证器::make($request->all(), [ 'credit_card_number' => 'required_if:payment_type,cc' ]);

如果此验证规则失败，将产生以下错误消息：

1
当付款类型为 cc 时，信用卡号字段是必填的。
当付款类型为 cc 时，信用卡号字段是必填的。

而不是显示 cc 作为付款类型值，您可以在您的 lang/xx/validation.php 通过定义一个语言文件 values 大批：

1
‘
值
‘

=>
[
2

‘
付款类型
‘

=>
[
3

‘
抄送
‘

=>

‘
信用卡
‘
4
]，
5
]，
'values' => [ 'payment_type' => [ 'cc' => '信用卡' ], ],

默认情况下，Laravel 应用程序骨架不包含 lang 目录。如果你想自定义 Laravel 的语言文件，你可以通过 lang:publish 工匠指挥。

定义该值后，验证规则将产生以下错误消息：

1
当付款类型为信用卡时，信用卡号字段是必填的。
当付款类型为信用卡时，信用卡号字段是必填的。

可用的验证规则

以下是所有可用的验证规则及其功能的列表：

布尔值

公认接受条件布尔值已拒绝如果拒绝

字符串

实用工具

公认

验证中的字段必须是 "yes" , "on" , 1 , "1" , true ，或者 "true" 这对于验证“服务条款”的接受或类似字段很有用。

Accepted_if：另一个字段，值，...

验证中的字段必须是 "yes" , "on" , 1 , "1" , true ，或者 "true" 如果验证中的另一个字段等于指定值。这对于验证“服务条款”接受或类似字段很有用。

active_url

验证字段必须具有有效的 A 或 AAAA 记录，具体取决于 dns_get_record PHP 函数。使用以下代码提取所提供 URL 的主机名： parse_url PHP 函数在传递给 dns_get_record 。

后：日期

验证字段必须是给定日期之后的值。日期将传递到 strtotime PHP 函数才能转换为有效的 DateTime 实例：

1
‘
开始日期
‘

=>

‘
必填|日期|之后：明天
‘
'start_date' => '必填|日期|之后：明天'

而不是传递要评估的日期字符串 strtotime ，您可以指定另一个字段来与日期进行比较：

1
‘
完成日期
‘

=>

‘
必填|日期|之后：开始日期
‘
'finish_date' => '必填|日期|之后：开始日期'

为了方便起见，可以使用流畅的 date 规则构建器：

1
使用
照亮\验证\
规则
;
2
3
‘
开始日期
‘

=>
[
4

‘
必需的
‘
,
5

规则
::
日期
（）
->
后
（
今天
（）
->
增加天数
（
7
)),
6
]，
使用 Illuminate\Validation\Rule；'start_date' => ['required', Rule::date()->after(today()->addDays(7)), ],

这 afterToday 和 todayOrAfter 方法可用于流畅地表达日期必须在今天之后或或今天或之后，分别为：

1
‘
开始日期
‘

=>
[
2

‘
必需的
‘
,
3

规则
::
日期
（）
->
今日之后
（），
4
]，
'start_date' => [ 'required', 规则::date()->afterToday(), ],

或相等之后：日期

验证字段的值必须是指定日期之后或等于该日期的值。有关更多信息，请参阅后规则。

为了方便起见，可以使用流畅的 date 规则构建器：

1
使用
照亮\验证\
规则
;
2
3
‘
开始日期
‘

=>
[
4

‘
必需的
‘
,
5

规则
::
日期
（）
->
或相等之后
（
今天
（）
->
增加天数
（
7
)),
6
]，
使用 Illuminate\Validation\Rule；'start_date' => ['required', Rule::date()->afterOrEqual(today()->addDays(7)), ],

阿尔法

验证字段必须完全由 Unicode 字母字符组成，并且包含在 \p{L} 和 \p{M} 。

要将此验证规则限制为 ASCII 范围内的字符 ( a-z 和 A-Z ），您可以提供 ascii 验证规则的选项：

1
‘
用户名
‘

=>

‘
字母：ASCII
‘
,
'用户名' => 'alpha:ascii',

alpha_dash

验证字段必须完全由 Unicode 字母数字字符组成， \p{L} , \p{M} , \p{N} 以及 ASCII 破折号 ( - ) 和 ASCII 下划线 ( _ ）。

要将此验证规则限制为 ASCII 范围内的字符 ( a-z 和 A-Z ），您可以提供 ascii 验证规则的选项：

1
‘
用户名
‘

=>

‘
alpha_dash:ascii
‘
,
'用户名' => 'alpha_dash:ascii',

字母数字

验证字段必须完全由 Unicode 字母数字字符组成， \p{L} , \p{M} ，和 \p{N} 。

要将此验证规则限制为 ASCII 范围内的字符 ( a-z 和 A-Z ），您可以提供 ascii 验证规则的选项：

1
‘
用户名
‘

=>

‘
字母数字：ASCII
‘
,
'用户名' => 'alpha_num:ascii',

大批

验证字段必须是 PHP array 。

当向 array 规则，输入数组中的每个键都必须存在于提供给规则的值列表中。在以下示例中， admin 输入数组中的键无效，因为它不包含在提供给 array 规则：

1
使用
照亮\支撑\外墙\
验证者
;
2
3
$输入

=
[
4

‘
用户
‘

=>
[
5

‘
姓名
‘

=>

‘
泰勒·奥特威尔
‘
,
6

‘
用户名
‘

=>

‘
泰勒洛特韦尔
‘
,
7

‘
行政
‘

=>

真的
,
8
]，
9
]；
10
11
验证者
::
制作
（
$输入
，[
12

‘
用户
‘

=>

‘
数组：名称，用户名
‘
,
13
]);
使用 Illuminate\Support\Facades\Validator; $input = [ 'user' => [ 'name' => 'Taylor Otwell', 'username' => 'taylorotwell', 'admin' => true, ], ]; Validator::make($input, [ 'user' => 'array:name,username', ]);

一般来说，您应该始终指定允许存在于数组中的数组键。

ASCII

验证的字段必须全部是 7 位 ASCII 字符。

保释

第一次验证失败后，停止运行该字段的验证规则。

虽然 bail 规则仅在遇到验证失败时才会停止验证特定字段， stopOnFirstFailure 方法将通知验证器，一旦发生单个验证失败，它应该停止验证所有属性：

1
如果
（
$验证器
->
第一次失败时停止
（）
->
失败
（））{
2

//
...
3
}
如果 ($validator->stopOnFirstFailure()->fails()) { // ... }

前：日期

验证的字段必须是给定日期之前的值。日期将传递到 PHP strtotime 函数才能转换成有效的 DateTime 例如。此外，像 after 规则，验证中的另一个字段的名称可以作为 date 。

为了方便起见，也可以使用流畅的 date 规则构建器：

1
使用
照亮\验证\
规则
;
2
3
‘
开始日期
‘

=>
[
4

‘
必需的
‘
,
5

规则
::
日期
（）
->
前
（
今天
（）
->
子日
（
7
)),
6
]，
使用 Illuminate\Validation\Rule；'start_date' => ['required', Rule::date()->before(today()->subDays(7)), ],

这 beforeToday 和 todayOrBefore 方法可以分别用于流畅地表达日期必须在今天之前或或今天或之前：

1
‘
开始日期
‘

=>
[
2

‘
必需的
‘
,
3

规则
::
日期
（）
->
今日之前
（），
4
]，
'start_date' => [ 'required', 规则::date()->beforeToday(), ],

之前或相等：日期

验证字段必须是给定日期之前或等于该日期的值。日期将传递到 PHP strtotime 函数才能转换成有效的 DateTime 例如。此外，像 after 规则，验证中的另一个字段的名称可以作为 date 。

为了方便起见，也可以使用流畅的 date 规则构建器：

1
使用
照亮\验证\
规则
;
2
3
‘
开始日期
‘

=>
[
4

‘
必需的
‘
,
5

规则
::
日期
（）
->
之前或相等
（
今天
（）
->
子日
（
7
)),
6
]，
使用 Illuminate\Validation\Rule；'start_date' => ['required', Rule::date()->beforeOrEqual(today()->subDays(7)), ],

之间：分钟 , 最大限度

验证字段的大小必须在给定的范围内分钟和 最大限度 （含）。字符串、数字、数组和文件的评估方式与 size 规则。

布尔值

验证的字段必须能够转换为布尔值。接受的输入是 true , false , 1 , 0 , "1" ，和 "0" 。

确认的

验证字段必须具有匹配的字段 {field}_confirmation 。例如，如果验证的字段是 password ，匹配 password_confirmation 字段必须存在于输入中。

您还可以传递自定义确认字段名称。例如， confirmed:repeat_username 将会期待领域 repeat_username 匹配验证下的字段。

包含：富 , 酒吧，...

验证下的字段必须是包含所有给定参数值的数组。

当前密码

验证字段必须与已验证用户的密码匹配。您可以指定认证守卫使用规则的第一个参数：

1
‘
密码
‘

=>

‘
当前密码：api
‘
'密码' => '当前密码：api'

日期

验证字段必须为有效的、非相对日期，具体如下： strtotime PHP 函数。

日期等于：日期

验证字段必须等于给定的日期。日期将传递到 PHP strtotime 函数才能转换成有效的 DateTime 实例。

日期格式：格式，...

验证字段必须与给定的字段之一匹配格式 . 你应该使用 任何一个 date 或者 date_format 验证字段时，不能同时验证两者。此验证规则支持 PHP 支持的所有格式日期时间班级。

为了方便起见，可以使用流畅的 date 规则构建器：

1
使用
照亮\验证\
规则
;
2
3
‘
开始日期
‘

=>
[
4

‘
必需的
‘
,
5

规则
::
日期
（）
->
格式
（
‘
尤姆
‘
),
6
]，
使用 Illuminate\Validation\Rule；'start_date' => ['required', Rule::date()->format('Ymd'), ],

小数：分钟 , 最大限度

验证字段必须是数字，且必须包含指定的小数位数：

1
//
必须有精确两位小数（9.99）...
2
‘
价格
‘

=>

‘
小数：2
‘
3
4
//
必须有 2 到 4 位小数...
5
‘
价格
‘

=>

‘
小数：2,4
‘
// 必须精确到小数点后两位（9.99）... 'price' => 'decimal:2' // 必须有 2 到 4 位小数... 'price' => 'decimal:2,4'

拒绝

验证中的字段必须是 "no" , "off" , 0 , "0" , false ，或者 "false" 。

decline_if：另一个字段，值，...

验证中的字段必须是 "no" , "off" , 0 , "0" , false ，或者 "false" 如果验证中的另一个字段等于指定值。

不同的：场地

验证字段的值必须不同于场地。

数字：价值

验证的整数必须具有以下精确长度：价值。

数字之间：分钟 , 最大限度

整数验证的长度必须在给定的范围内分钟和 最大限度 。

方面

验证的文件必须是符合规则参数指定的尺寸限制的图像：

1
‘
头像
‘

=>

‘
尺寸：最小宽度=100，最小高度=200
‘
'头像' => '尺寸：最小宽度=100，最小高度=200'

可用的约束包括： 最小宽度 , 最大宽度 , 最小高度 , 最大高度 , 宽度 , 高度 , 比率。

A 比率约束应表示为宽度除以高度。这可以通过以下分数来指定： 3/2 或者像 1.5 :

1
‘
头像
‘

=>

‘
尺寸：比例=3/2
‘
'头像' => '尺寸：比例=3/2'

由于此规则需要几个参数，因此使用 Rule::dimensions 流畅地构建规则的方法：

1
使用
照亮\支撑\外墙\
验证者
;
2
使用
照亮\验证\
规则
;
3
4
验证者
::
制作
（
$数据
，[
5

‘
头像
‘

=>
[
6

‘
必需的
‘
,
7

规则
::
方面
（）
8

->
最大宽度
（
1000
）
9

->
最大高度
（
500
）
10

->
比率
（
3

/

2
),
11
]，
12
]);
使用 Illuminate\Support\Facades\Validator；使用 Illuminate\Validation\Rule；Validator::make($data, [ 'avatar' => [ 'required', Rule::dimensions() ->maxWidth(1000) ->maxHeight(500) ->ratio(3 / 2), ], ]);

清楚的

验证数组时，验证的字段不能有任何重复的值：

1
‘
foo.*.id
‘

=>

‘
清楚的
‘
‘foo.*.id’ => ‘distinct’

Distinct 默认使用宽松变量比较。要使用严格比较，您可以添加 strict 验证规则定义的参数：

1
‘
foo.*.id
‘

=>

‘
不同：严格
‘
'foo.*.id' => 'distinct:strict'

您可以添加 ignore_case 验证规则的参数，使规则忽略大小写差异：

1
‘
foo.*.id
‘

=>

‘
不同：忽略大小写
‘
'foo.*.id' => 'distinct:ignore_case'

不以下列方式开始：富 , 酒吧，...

验证的字段不能以给定的值之一开头。

没有结束：富 , 酒吧，...

验证的字段不能以给定的值之一结尾。

电子邮件

验证字段必须格式化为电子邮件地址。此验证规则利用 egulias/email-validator 用于验证电子邮件地址的包。默认情况下， RFCValidation 已应用验证器，但您也可以应用其他验证样式：

1
‘
电子邮件
‘

=>

‘
电子邮件：rfc，dns
‘
'电子邮件' => '电子邮件：rfc，dns'

上面的例子将应用 RFCValidation 和 DNSCheckValidation 验证。以下是您可以应用的验证样式的完整列表：

rfc : RFCValidation - 根据 RFC 5322 验证电子邮件地址。
strict : NoRFCWarningsValidation - 根据 RFC 5322 验证电子邮件，拒绝尾随句点或多个连续句点。
dns : DNSCheckValidation - 确保电子邮件地址的域名具有有效的 MX 记录。
spoof : SpoofCheckValidation - 确保电子邮件地址不包含同形异义词或欺骗性的 Unicode 字符。
filter : FilterEmailValidation - 确保电子邮件地址符合 PHP 的 filter_var 功能。
filter_unicode : FilterEmailValidation::unicode() - 确保电子邮件地址符合 PHP 的 filter_var 功能，允许一些 Unicode 字符。

为了方便起见，可以使用流畅的规则构建器来构建电子邮件验证规则：

1
使用
照亮\验证\
规则
;
2
3
$请求
->
证实
（[
4

‘
电子邮件
‘

=>
[
5

‘
必需的
‘
,
6

规则
::
电子邮件
（）
7

->
符合 rfc
（严格的：
错误的
）
8

->
验证MxRecord
（）
9

->
防止欺骗
（）
10
]，
11
]);
使用 Illuminate\Validation\Rule；$request->validate([ 'email' => [ 'required', Rule::email() ->rfcCompliant(strict: false) ->validateMxRecord() ->preventSpoofing() ], ]);

这 dns 和 spoof 验证器需要 PHP intl 扩大。

结尾：富 , 酒吧，...

验证的字段必须以给定值之一结尾。

枚举

这 Enum 规则是基于类的规则，用于验证所验证的字段是否包含有效的枚举值。 Enum 规则接受枚举的名称作为其唯一的构造函数参数。在验证原始值时，应向 Enum 规则：

1
使用
应用程序\枚举\
服务器状态
;
2
使用
照亮\验证\
规则
;
3
4
$请求
->
证实
（[
5

‘
地位
‘

=>
[
规则
::
枚举
（
服务器状态
::
班级
)]，
6
]);
使用 App\Enums\ServerStatus；使用 Illuminate\Validation\Rule；$request->validate(['status' => [Rule::enum(ServerStatus::class)],]);

这 Enum 规则的 only 和 except 可以使用方法来限制哪些枚举案例应被视为有效：

1
规则
::
枚举
（
服务器状态
::
班级
）
2

->
仅有的
（[
服务器状态
::
待办的
,
服务器状态
::
积极的
]);
3
4
规则
::
枚举
（
服务器状态
::
班级
）
5

->
除了
（[
服务器状态
::
待办的
,
服务器状态
::
积极的
]);
规则::枚举（ServerStatus::class）->only（[ServerStatus::Pending，ServerStatus::Active]）； 规则::枚举（ServerStatus::class）->except（[ServerStatus::Pending，ServerStatus::Active]）；

这 when 方法可以有条件地修改 Enum 规则：

1
使用
照亮\支撑\外墙\
授权
;
2
使用
照亮\验证\
规则
;
3
4
规则
::
枚举
（
服务器状态
::
班级
）
5

->
什么时候
（
6

授权
::
用户
（）
->
管理员
（），
7

fn

（
$规则
）
=>
$规则
->
仅有的
（
...
),
8

fn

（
$规则
）
=>
$规则
->
仅有的
（
...
),
9
（英文）：
使用 Illuminate\Support\Facades\Auth；使用 Illuminate\Validation\Rule；规则::枚举（ServerStatus::class）->when（Auth::user()->isAdmin()，fn ($rule) => $rule->only(...)，fn ($rule) => $rule->only(...)，）；

排除

验证字段将从返回的请求数据中排除 validate 和 validated 方法。

排除条件：另一个领域 , 价值

验证字段将从返回的请求数据中排除 validate 和 validated 方法，如果 另一个领域 字段等于价值。

如果需要复杂的条件排除逻辑，你可以利用 Rule::excludeIf 方法。此方法接受布尔值或闭包。当给定闭包时，闭包应该返回 true 或者 false 指示是否应排除验证字段：

1
使用
照亮\支撑\外墙\
验证者
;
2
使用
照亮\验证\
规则
;
3
4
验证者
::
制作
（
$请求
->
全部
（），[
5

‘
角色 ID
‘

=>

规则
::
排除如果
（
$请求
->
用户
（）
->是_管理员
),
6
]);
7
8
验证者
::
制作
（
$请求
->
全部
（），[
9

‘
角色 ID
‘

=>

规则
::
排除如果
（
fn

（）
=>
$请求
->
用户
（）
->是_管理员
),
10
]);
使用 Illuminate\Support\Facades\Validator；使用 Illuminate\Validation\Rule；验证器::make($request->all()，['role_id' => Rule::excludeIf($request->user()->is_admin),]); 验证器::make($request->all()，['role_id' => Rule::excludeIf(fn () => $request->user()->is_admin),]);

排除_除非：另一个领域 , 价值

验证字段将从返回的请求数据中排除 validate 和 validated 方法，除非 另一个领域 的字段等于价值。如果价值是 null （ exclude_unless:name,null ），除非比较字段是 null 或者请求数据中缺少比较字段。

排除：另一个领域

验证字段将从返回的请求数据中排除 validate 和 validated 方法，如果 另一个领域 字段存在。

排除：另一个领域

验证字段将从返回的请求数据中排除 validate 和 validated 方法，如果 另一个领域 字段不存在。

存在：桌子 , 柱子

验证的字段必须存在于给定的数据库表中。

存在规则的基本用法

1
‘
状态
‘

=>

‘
存在：状态
‘
'state' => '存在：状态'

如果 column 选项未指定时，将使用字段名称。因此，在这种情况下，规则将验证 states 数据库表包含一条记录，其中 state 与请求匹配的列值 state 属性值。

指定自定义列名称

您可以通过将验证规则应使用的数据库列名放在数据库表名之后来明确指定它：

1
‘
状态
‘

=>

‘
存在：状态，缩写
‘
'state' => '存在：州，缩写'

有时，您可能需要指定要用于的特定数据库连接 exists 查询。您可以通过将连接名称添加到表名称前面来实现此目的：

1
‘
电子邮件
‘

=>

‘
存在：connection.staff，电子邮件
‘
'email' => '存在：connection.staff，电子邮件'

除了直接指定表名之外，您还可以指定用于确定表名的 Eloquent 模型：

1
‘
用户身份
‘

=>

‘
存在：App\Models\User，id
‘
'user_id' => '存在：App\Models\User，id'

如果你想自定义验证规则执行的查询，你可以使用 Rule 类来流畅地定义规则。在此示例中，我们还将以数组形式指定验证规则，而不是使用 | 字符来分隔它们：

1
使用
照亮\数据库\查询\
建造者
;
2
使用
照亮\支撑\外墙\
验证者
;
3
使用
照亮\验证\
规则
;
4
5
验证者
::
制作
（
$数据
，[
6

‘
电子邮件
‘

=>
[
7

‘
必需的
‘
,
8

规则
::
存在
（
‘
职员
‘
）
->
在哪里
（
功能

（
建造者

$查询
）
{
9

$查询
->
在哪里
（
‘
账户编号
‘
,
1
（英文）：
10
}),
11
]，
12
]);
使用 Illuminate\Database\Query\Builder；使用 Illuminate\Support\Facades\Validator；使用 Illuminate\Validation\Rule；验证器::make($data，['email' => ['required'，Rule::exists('staff')->where(function (Builder $query) {$query->where('account_id', 1);}),],]);

您可以明确指定应该使用的数据库列名称 exists 规则生成 Rule::exists 方法通过将列名作为第二个参数传递给 exists 方法：

1
‘
状态
‘

=>

规则
::
存在
（
‘
州
‘
,
‘
缩写
‘
),
'state' => 规则::exists('states', 'abbreviation'),

扩展：富 , 酒吧，...

验证的文件必须具有与列出的扩展名之一相对应的用户分配的扩展名：

1
‘
照片
‘

=>
[
‘
必需的
‘
,
‘
扩展名：jpg、png
‘
]，
'photo' => ['必填', '扩展名：jpg,png'],

您永远不应该仅依赖用户指定的扩展名来验证文件。此规则通常应始终与 mimes 或者 mimetypes 規則。

文件

验证下的字段必须是成功上传的文件。

已填满

验证字段存在时不能为空。

GT：场地

验证字段必须大于给定的场地或者价值。两个字段必须是同一类型。字符串、数字、数组和文件使用与 size 规则。

gte：场地

验证字段必须大于或等于给定的场地或者价值。两个字段必须是同一类型。字符串、数字、数组和文件使用与 size 规则。

十六进制颜色

验证字段必须包含有效的颜色值十六进制格式。

图像

验证的文件必须是图像（jpg、jpeg、png、bmp、gif、svg 或 webp）。

在：富 , 酒吧，...

验证的字段必须包含在给定的值列表中。由于此规则通常要求您 implode 一个数组， Rule::in 方法可以用来流畅地构建规则：

1
使用
照亮\支撑\外墙\
验证者
;
2
使用
照亮\验证\
规则
;
3
4
验证者
::
制作
（
$数据
，[
5

‘
区域
‘

=>
[
6

‘
必需的
‘
,
7

规则
::
在
（[
‘
第一区
‘
,
‘
第二区
‘
]),
8
]，
9
]);
使用 Illuminate\Support\Facades\Validator；使用 Illuminate\Validation\Rule；Validator::make($data, [ 'zones' => [ 'required', Rule::in(['first-zone', 'second-zone']), ], ]);

当 in 规则与 array 规则是，输入数组中的每个值都必须存在于提供给 in 规则。在下面的例子中， LAS 输入数组中的机场代码无效，因为它不包含在提供给 in 规则：

1
使用
照亮\支撑\外墙\
验证者
;
2
使用
照亮\验证\
规则
;
3
4
$输入

=
[
5

‘
机场
‘

=>
[
‘
纽约
‘
,
‘
这
‘
]，
6
]；
7
8
验证者
::
制作
（
$输入
，[
9

‘
机场
‘

=>
[
10

‘
必需的
‘
,
11

‘
大批
‘
,
12
]，
13

‘
机场。*
‘

=>

规则
::
在
（[
‘
纽约
‘
,
‘
激光扫描
‘
]),
14
]);
使用 Illuminate\Support\Facades\Validator；使用 Illuminate\Validation\Rule；$input = [ 'airports' => ['NYC', 'LAS'], ]; Validator::make($input, [ 'airports' => [ 'required', 'array', ], 'airports.*' => Rule::in(['NYC', 'LIT']), ]);

数组中：另一个领域 .*

验证的字段必须存在于 另一个领域 的价值观。

整数

验证的字段必须是整数。

此验证规则不会验证输入是否为“整数”变量类型，而只是验证输入是否为 PHP 接受的类型 FILTER_VALIDATE_INT 规则。如果您需要验证输入是否为数字，请将此规则与这 numeric 验证规则。

知识产权

验证的字段必须是IP地址。

IPv4

验证的字段必须是 IPv4 地址。

IPv6 协议

验证的字段必须是 IPv6 地址。

json

验证的字段必须是有效的JSON字符串。

lt：场地

验证字段必须小于给定值场地。两个字段必须是同一类型。字符串、数字、数组和文件使用与 size 规则。

LTE：场地

验证字段必须小于或等于给定的场地。两个字段必须是同一类型。字符串、数字、数组和文件使用与 size 规则。

小写

验证的字段必须是小写。

列表

验证的字段必须是一个列表数组。如果数组的键由从 0 到 count($array) - 1 。

mac_地址

验证的字段必须是MAC地址。

最大限度：价值

验证字段必须小于或等于最大值价值字符串、数字、数组和文件的评估方式与 size 规则。

最大数字：价值

验证的整数的最大长度必须为价值。

模仿类型：文本/纯文本，...

验证的文件必须与给定的 MIME 类型之一匹配：

1
‘
视频
‘

=>

‘
mimetypes：视频/avi、视频/mpeg、视频/quicktime
‘
'video' => 'mimetypes：视频/avi，视频/mpeg，视频/quicktime'

为了确定上传文件的 MIME 类型，将读取文件的内容并且框架将尝试猜测 MIME 类型，该类型可能与客户端提供的 MIME 类型不同。

哑剧：富 , 酒吧，...

验证的文件必须具有与列出的扩展名之一相对应的 MIME 类型：

1
‘
照片
‘

=>

‘
模仿秀：jpg、bmp、png
‘
'照片' => 'mimes:jpg,bmp,png'

尽管您只需要指定扩展名，但此规则实际上会通过读取文件内容并猜测其 MIME 类型来验证文件的 MIME 类型。您可以在以下位置找到 MIME 类型及其对应扩展名的完整列表：

https://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types

MIME 类型和扩展

此验证规则不验证 MIME 类型与用户分配给文件的扩展名之间的一致性。例如， mimes:png 验证规则会将包含有效 PNG 内容的文件视为有效的 PNG 图像，即使该文件名为 photo.txt 。如果您想验证文件的用户指定扩展名，您可以使用 extensions 规则。

分钟：价值

验证字段必须至少包含价值字符串、数字、数组和文件的评估方式与 size 规则。

最小数字：价值

验证的整数必须至少具有价值。

多个：价值

验证字段必须是价值。

丢失的

验证的字段不能存在于输入数据中。

缺失_if：另一个领域 , 价值，...

如果 另一个领域 字段等于任何价值。

缺失_除非：另一个领域 , 价值

验证中的字段不得存在，除非 另一个领域 字段等于任何价值。

缺失值：富 , 酒吧，...

验证中的字段不能存在 只有当 任何其他指定字段都存在。

全部缺失：富 , 酒吧，...

验证中的字段不能存在 只有当 所有其他指定字段均存在。

不在：富 , 酒吧，...

验证的字段不得包含在给定的值列表中。 Rule::notIn 方法可以用来流畅地构建规则：

1
使用
照亮\验证\
规则
;
2
3
验证者
::
制作
（
$数据
，[
4

‘
配料
‘

=>
[
5

‘
必需的
‘
,
6

规则
::
游泳
（[
‘
洒
‘
,
‘
樱桃
‘
]),
7
]，
8
]);
使用 Illuminate\Validation\Rule；验证器::make($data, [ 'toppings' => [ 'required', Rule::notIn(['sprinkles', 'cherries']), ], ]);

非正则表达式：图案

验证的字段不能与给定的正则表达式匹配。

在内部，此规则使用 PHP preg_match 函数。指定的模式应遵循 preg_match 因此也包括有效的分隔符。例如： 'email' => 'not_regex:/^.+$/i' 。

使用时 regex / not_regex 模式，可能需要使用数组而不是使用来指定验证规则 | 分隔符，特别是当正则表达式包含 | 特点。

可空

验证中的字段可能是 null 。

数字

验证中的字段必须是数字。

展示

验证的字段必须存在于输入数据中。

present_if：另一个领域 , 价值，...

如果 另一个领域 字段等于任何价值。

present_unless：另一个领域 , 价值

验证字段必须存在，除非 另一个领域 字段等于任何价值。

present_with：富 , 酒吧，...

验证字段必须存在 只有当 任何其他指定字段都存在。

呈现全部：富 , 酒吧，...

验证字段必须存在 只有当 所有其他指定字段均存在。

禁止

验证的字段必须缺失或为空。如果字段满足以下条件之一，则为“空”：

价值是 null 。
该值为空字符串。
值为空数组或空 Countable 目的。
该值是一个已上传的文件，路径为空。

禁止_如果：另一个领域 , 价值，...

如果 另一个领域 字段等于任何价值如果字段满足以下条件之一，则该字段为“空”：

价值是 null 。
该值为空字符串。
值为空数组或空 Countable 目的。
该值是一个已上传的文件，路径为空。

如果需要复杂的条件禁止逻辑，您可以使用 Rule::prohibitedIf 方法。此方法接受布尔值或闭包。当给定闭包时，闭包应该返回 true 或者 false 指示是否应禁止验证字段：

1
使用
照亮\支撑\外墙\
验证者
;
2
使用
照亮\验证\
规则
;
3
4
验证者
::
制作
（
$请求
->
全部
（），[
5

‘
角色 ID
‘

=>

规则
::
禁止如果
（
$请求
->
用户
（）
->是_管理员
),
6
]);
7
8
验证者
::
制作
（
$请求
->
全部
（），[
9

‘
角色 ID
‘

=>

规则
::
禁止如果
（
fn

（）
=>
$请求
->
用户
（）
->是_管理员
),
10
]);
使用 Illuminate\Support\Facades\Validator；使用 Illuminate\Validation\Rule；验证器::make($request->all()，['role_id' => Rule::prohibitedIf($request->user()->is_admin),]); 验证器::make($request->all()，['role_id' => Rule::prohibitedIf(fn () => $request->user()->is_admin),]);

禁止_除非：另一个领域 , 价值，...

验证字段必须缺失或为空，除非 另一个领域 字段等于任何价值如果字段满足以下条件之一，则该字段为“空”：

价值是 null 。
该值为空字符串。
值为空数组或空 Countable 目的。
该值是一个已上传的文件，路径为空。

禁止：另一个领域，...

如果验证字段没有缺失或为空，则 另一个领域 必须缺失或为空。如果字段满足以下条件之一，则为“空”：

价值是 null 。
该值为空字符串。
值为空数组或空 Countable 目的。
该值是一个已上传的文件，路径为空。

正则表达式：图案

验证的字段必须与给定的正则表达式匹配。

在内部，此规则使用 PHP preg_match 函数。指定的模式应遵循 preg_match 因此也包括有效的分隔符。例如： 'email' => 'regex:/^.+@.+$/i' 。

使用时 regex / not_regex 模式，可能需要在数组中指定规则，而不是使用 | 分隔符，特别是当正则表达式包含 | 特点。

必需的

验证的字段必须存在于输入数据中且不能为空。如果字段满足以下条件之一，则为“空”：

价值是 null 。
该值为空字符串。
值为空数组或空 Countable 目的。
该值是已上传的文件，没有路径。

必填项：另一个领域 , 价值，...

验证字段必须存在且不能为空，如果 另一个领域 字段等于任何价值。

如果你想为 required_if 规则，您可以使用 Rule::requiredIf 方法。此方法接受布尔值或闭包。当传递闭包时，闭包应该返回 true 或者 false 指示验证字段是否为必填：

1
使用
照亮\支撑\外墙\
验证者
;
2
使用
照亮\验证\
规则
;
3
4
验证者
::
制作
（
$请求
->
全部
（），[
5

‘
角色 ID
‘

=>

规则
::
必填项If
（
$请求
->
用户
（）
->是_管理员
),
6
]);
7
8
验证者
::
制作
（
$请求
->
全部
（），[
9

‘
角色 ID
‘

=>

规则
::
必填项If
（
fn

（）
=>
$请求
->
用户
（）
->是_管理员
),
10
]);
使用 Illuminate\Support\Facades\Validator；使用 Illuminate\Validation\Rule；验证器::make($request->all()，['role_id' => Rule::requiredIf($request->user()->is_admin),]); 验证器::make($request->all()，['role_id' => Rule::requiredIf(fn () => $request->user()->is_admin),]);

接受时必填：另一个领域，...

验证字段必须存在且不能为空，如果 另一个领域 字段等于 "yes" , "on" , 1 , "1" , true ，或者 "true" 。

拒绝时必填：另一个领域，...

验证字段必须存在且不能为空，如果 另一个领域 字段等于 "no" , "off" , 0 , "0" , false ，或者 "false" 。

必需_除非：另一个领域 , 价值，...

验证字段必须存在且不能为空，除非 另一个领域 字段等于任何价值 .这也意味着 另一个领域 必须存在于请求数据中，除非价值是 null 。如果价值是 null （ required_unless:name,null ），除非比较字段是 null 或者请求数据中缺少比较字段。

必需：富 , 酒吧，...

验证字段必须存在且不能为空 只有当 任何其他指定字段都存在且不为空。

全部必填：富 , 酒吧，...

验证字段必须存在且不能为空 只有当 所有其他指定字段均存在且不为空。

必需_不含：富 , 酒吧，...

验证字段必须存在且不能为空 只有当 任何其他指定字段为空或不存在。

必需（不含全部）：富 , 酒吧，...

验证字段必须存在且不能为空 只有当 所有其他指定的字段都为空或不存在。

必需的数组键：富 , 酒吧，...

验证下的字段必须是一个数组，并且必须至少包含指定的键。

相同的：场地

给定场地必须与验证下的字段相匹配。

尺寸：价值

验证字段的大小必须与给定的价值 . 对于字符串数据，价值对应于字符数。对于数字数据，价值对应于给定的整数值（该属性还必须具有 numeric 或者 integer 规则）。对于数组，尺寸对应于 count 数组。对于文件，尺寸对应于文件大小（以千字节为单位）。让我们看一些示例：

1
//
验证字符串长度确实为 12 个字符......
2
‘
标题
‘

=>

‘
尺寸：12
‘
;
3
4
//
验证提供的整数是否等于 10...
5
‘
座位
‘

=>

‘
整数|大小：10
‘
;
6
7
//
验证数组是否恰好有 5 个元素...
8
‘
标签
‘

=>

‘
数组|大小：5
‘
;
9
10
//
验证上传的文件是否正好是 512 千字节......
11
‘
图像
‘

=>

‘
文件|大小：512
‘
;
// 验证字符串长度正好为 12 个字符... 'title' => 'size:12'; // 验证提供的整数等于 10... 'seats' => 'integer|size:10'; // 验证数组正好有 5 个元素... 'tags' => 'array|size:5'; // 验证上传的文件正好为 512 千字节... 'image' => 'file|size:512';

开始于：富 , 酒吧，...

验证下的字段必须以给定值之一开头。

细绳

验证的字段必须是字符串。如果您希望允许该字段也是 null ，你应该分配 nullable 统治该领域。

时区

验证字段必须为有效的时区标识符 DateTimeZone::listIdentifiers 方法。

论点被接受 DateTimeZone::listIdentifiers 方法也可以提供给这个验证规则：

1
‘
时区
‘

=>

‘
必填|时区：全部
‘
;
2
3
‘
时区
‘

=>

‘
必填|时区：非洲
‘
;
4
5
‘
时区
‘

=>

‘
必填|时区：每个国家，美国
‘
;
'timezone' => 'required|timezone:all'; 'timezone' => 'required|timezone:Africa'; 'timezone' => 'required|timezone:per_country,US';

独特的：桌子 , 柱子

验证的字段在给定的数据库表中一定不存在。

指定自定义表/列名称：

除了直接指定表名之外，您还可以指定用于确定表名的 Eloquent 模型：

1
‘
电子邮件
‘

=>

‘
唯一：App\Models\User，电子邮件地址
‘
'电子邮件' => '唯一：应用程序\模型\用户，电子邮件地址'

这 column 选项可用于指定字段对应的数据库列。如果 column 如果未指定选项，则将使用验证下的字段名称。

1
‘
电子邮件
‘

=>

‘
唯一：用户，电子邮件地址
‘
'email' => '唯一：用户，电子邮件地址'

指定自定义数据库连接

有时，您可能需要为验证器所做的数据库查询设置自定义连接。为此，您可以将连接名称添加到表名称的前面：

1
‘
电子邮件
‘

=>

‘
唯一：connection.users，email_address
‘
'电子邮件' => '唯一：connection.users，电子邮件地址'

强制执行唯一规则以忽略给定的 ID：

有时，您可能希望在唯一性验证期间忽略给定的 ID。例如，考虑一个包含用户姓名、电子邮件地址和位置的“更新个人资料”屏幕。您可能希望验证电子邮件地址是否唯一。但是，如果用户仅更改姓名字段而不更改电子邮件字段，您不希望抛出验证错误，因为用户已经是相关电子邮件地址的所有者。

为了指示验证器忽略用户的 ID，我们将使用 Rule 类来流畅地定义规则。在此示例中，我们还将以数组形式指定验证规则，而不是使用 | 字符界定规则：

1
使用
照亮\支撑\外墙\
验证者
;
2
使用
照亮\验证\
规则
;
3
4
验证者
::
制作
（
$数据
，[
5

‘
电子邮件
‘

=>
[
6

‘
必需的
‘
,
7

规则
::
独特的
（
‘
用户
‘
）
->
忽略
（
$用户
->id
),
8
]，
9
]);
使用 Illuminate\Support\Facades\Validator；使用 Illuminate\Validation\Rule；Validator::make($data, [ 'email' => [ 'required', Rule::unique('users')->ignore($user->id), ], ]);

您永远不应该将任何用户控制的请求输入传递到 ignore 方法。相反，您应该只传递系统生成的唯一 ID，例如来自 Eloquent 模型实例的自动递增 ID 或 UUID。否则，您的应用程序将容易受到 SQL 注入攻击。

而不是将模型键的值传递给 ignore 方法，你也可以传递整个模型实例。Laravel 会自动从模型中提取密钥：

1
规则
::
独特的
（
‘
用户
‘
）
->
忽略
（
$用户
）
规则::unique('users')->ignore($user)

如果您的表使用的主键列名称不是 id ，您可以在调用时指定列的名称 ignore 方法：

1
规则
::
独特的
（
‘
用户
‘
）
->
忽略
（
$用户
->id
,
‘
用户身份
‘
）
规则::unique('users')->ignore($user->id，'user_id')

默认情况下， unique 规则将检查与被验证属性名称匹配的列的唯一性。但是，你可以将不同的列名称作为第二个参数传递给 unique 方法：

1
规则
::
独特的
（
‘
用户
‘
,
‘
电子邮件地址
‘
）
->
忽略
（
$用户
->id
）
规则::unique('users', 'email_address')->ignore($user->id)

添加额外的 Where 子句：

您可以通过使用以下方式自定义查询来指定其他查询条件 where 方法。例如，让我们添加一个查询条件，将查询范围限定为仅搜索具有 account_id 列值 1 :

1
‘
电子邮件
‘

=>

规则
::
独特的
（
‘
用户
‘
）
->
在哪里
（
fn

（
建造者

$查询
）
=>
$查询
->
在哪里
（
‘
账户编号
‘
,
1
））
'email' => 规则::unique('users')->where(fn (Builder $query) => $query->where('account_id', 1))

在唯一检查中忽略软删除记录：

默认情况下，唯一性规则在确定唯一性时会包含软删除记录。要从唯一性检查中排除软删除记录，您可以调用 withoutTrashed 方法：

1
规则
::
独特的
（
‘
用户
‘
）
->
沒有垃圾
（）；
规则::unique('users')->withoutTrashed();

如果您的模型使用除以下之外的列名称 deleted_at 对于软删除的记录，你可以在调用时提供列名 withoutTrashed 方法：

1
规则
::
独特的
（
‘
用户
‘
）
->
沒有垃圾
（
‘
被删除于
‘
（英文）：
规则::unique('users')->withoutTrashed('was_deleted_at');

大写

验证的字段必须是大写。

网址

验证下的字段必须是有效的 URL。

如果您想指定应被视为有效的 URL 协议，您可以将协议作为验证规则参数传递：

1
‘
网址
‘

=>

‘
网址:http,https
‘
,
2
3
‘
游戏
‘

=>

‘
网址：minecraft，steam
‘
,
'url' => 'url:http,https', 'game' => 'url:minecraft,steam',

乌利德

验证中的字段必须是有效的通用唯一且按字典顺序排序的标识符（有效身份证件）。

唯一标识

验证的字段必须是有效的 RFC 9562（版本 1、3、4、5、6、7 或 8）通用唯一标识符 (UUID)。

有条件地添加规则

当字段具有特定值时跳过验证

您可能偶尔希望在另一个字段具有给定值时不验证给定字段。您可以使用 exclude_if 验证规则。在此示例中， appointment_date 和 doctor_name 如果 has_appointment 字段的值为 false :

1
使用
照亮\支撑\外墙\
验证者
;
2
3
$验证器

=

验证者
::
制作
（
$数据
，[
4

‘
有预约
‘

=>

‘
必填|布尔值
‘
,
5

‘
预约日期
‘

=>

‘
排除条件：有预约，false|必填|日期
‘
,
6

‘
医生姓名
‘

=>

‘
排除条件：有预约，false|必填|字符串
‘
,
7
]);
使用 Illuminate\Support\Facades\Validator；$validator = Validator::make($data, [ 'has_appointment' => 'required|boolean', 'appointment_date' => 'exclude_if:has_appointment,false|required|date', 'doctor_name' => 'exclude_if:has_appointment,false|required|string', ]);

或者，您可以使用 exclude_unless 除非另一个字段具有给定值，否则不验证给定字段的规则：

1
$验证器

=

验证者
::
制作
（
$数据
，[
2

‘
有预约
‘

=>

‘
必填|布尔值
‘
,
3

‘
预约日期
‘

=>

‘
排除除非：有预约，true|需要|日期
‘
,
4

‘
医生姓名
‘

=>

‘
排除除非：有预约，true|必需|字符串
‘
,
5
]);
$validator = Validator::make($data, [ 'has_appointment' => 'required|boolean', 'appointment_date' => 'exclude_unless:has_appointment,true|required|date', 'doctor_name' => 'exclude_unless:has_appointment,true|required|string', ]);

存在时进行验证

在某些情况下，您可能希望针对某个字段运行验证检查 仅有的 如果该字段存在于要验证的数据中。要快速完成此操作，请添加 sometimes 将规则添加到您的规则列表中：

1
$验证器

=

验证者
::
制作
（
$数据
，[
2

‘
电子邮件
‘

=>

‘
有时|必填|电子邮件
‘
,
3
]);
$validator = Validator::make($data, [ 'email' => '有时|必需|email', ]);

在上面的例子中， email 仅当字段存在于 $data 大批。

如果你尝试验证一个应该始终存在但可能为空的字段，请查看关于可选字段的说明。

复杂条件验证

有时您可能希望添加基于更复杂的条件逻辑的验证规则。例如，您可能希望仅当另一个字段的值大于 100 时才要求给定字段。或者，您可能需要两个字段仅在存在另一个字段时才具有给定值。添加这些验证规则并不一定很麻烦。首先，创建一个 Validator 例如你的 静态规则 永远不会改变：

1
使用
照亮\支撑\外墙\
验证者
;
2
3
$验证器

=

验证者
::
制作
（
$请求
->
全部
（），[
4

‘
电子邮件
‘

=>

‘
必填|邮箱
‘
,
5

‘
游戏
‘

=>

‘
必填|数字
‘
,
6
]);
使用 Illuminate\Support\Facades\Validator；$validator = Validator::make($request->all(), [ 'email' => 'required|email', 'games' => 'required|numeric', ]);

假设我们的 Web 应用程序面向游戏收藏者。如果游戏收藏者在我们的应用程序中注册并且他们拥有 100 多个游戏，我们希望他们解释为什么他们拥有这么多游戏。例如，也许他们经营一家游戏转售店，或者他们只是喜欢收集游戏。要有条件地添加此要求，我们可以使用 sometimes 方法上的 Validator 实例。

1
使用
照亮\支持\
流利
;
2
3
$验证器
->
有时
（
‘
原因
‘
,
‘
必填|最大：500
‘
,
功能

（
流利

$输入
）
{
4

返回

$输入
->游戏

>=

100
;
5
});
使用 Illuminate\Support\Fluent；$validator->sometimes('reason', 'required|max:500', 函数 (Fluent $input) { return $input->games >= 100; });

传递给 sometimes method 是我们要进行条件验证的字段的名称。第二个参数是我们要添加的规则列表。如果作为第三个参数传递的闭包返回 true ，规则将被添加。此方法使构建复杂的条件验证变得轻而易举。您甚至可以一次为多个字段添加条件验证：

1
$验证器
->
有时
（[
‘
原因
‘
,
‘
成本
‘
]，
‘
必需的
‘
,
功能

（
流利

$输入
）
{
2

返回

$输入
->游戏

>=

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

这 $input 传递给闭包的参数将是 Illuminate\Support\Fluent 并可用于访问您的输入和正在验证的文件。

复杂条件数组验证

有时，您可能希望根据同一嵌套数组中的另一个字段来验证某个字段，但您不知道该字段的索引。在这些情况下，您可以让闭包接收第二个参数，该参数将是正在验证的数组中的当前单个项目：

1
$输入

=
[
2

‘
频道
‘

=>
[
3
[
4

‘
类型
‘

=>

‘
电子邮件
‘
,
5

‘
地址
‘

=>

‘
[电子邮件保护]
‘
,
6
]，
7
[
8

‘
类型
‘

=>

‘
网址
‘
,
9

‘
地址
‘

=>

‘
https://example.com
‘
,
10
]，
11
]，
12
]；
13
14
$验证器
->
有时
（
‘
渠道.*.地址
‘
,
‘
电子邮件
‘
,
功能

（
流利

$输入
,
流利

$item
）
{
15

返回

$item
->类型

===

‘
电子邮件
‘
;
16
});
17
18
$验证器
->
有时
（
‘
渠道.*.地址
‘
,
‘
网址
‘
,
功能

（
流利

$输入
,
流利

$item
）
{
19

返回

$item
->类型

!==

‘
电子邮件
‘
;
20
});
$输入=[
'渠道' => [
[
'类型' => '电子邮件',
'地址' => '
[电子邮件保护]
'，
]，
[
'类型' => '网址',
'address' => 'https://example.com',
]，
]，
]；
$validator->sometimes('channels.*.address', 'email', 函数 (Fluent $input, Fluent $item) {
返回 $item->type === 'email';
});
$validator->sometimes('channels.*.address', 'url', 函数 (Fluent $input, Fluent $item) {
返回 $item->type !== 'email';
});

就像 $input 传递给闭包的参数， $item 参数是 Illuminate\Support\Fluent 当属性数据是数组时；否则，它是一个字符串。

验证数组

正如在 array 验证规则文档，这 array 规则接受允许的数组键列表。如果数组中存在任何其他键，验证将失败：

1
使用
照亮\支撑\外墙\
验证者
;
2
3
$输入

=
[
4

‘
用户
‘

=>
[
5

‘
姓名
‘

=>

‘
泰勒·奥特威尔
‘
,
6

‘
用户名
‘

=>

‘
泰勒洛特韦尔
‘
,
7

‘
行政
‘

=>

真的
,
8
]，
9
]；
10
11
验证者
::
制作
（
$输入
，[
12

‘
用户
‘

=>

‘
数组：名称，用户名
‘
,
13
]);
使用 Illuminate\Support\Facades\Validator; $input = [ 'user' => [ 'name' => 'Taylor Otwell', 'username' => 'taylorotwell', 'admin' => true, ], ]; Validator::make($input, [ 'user' => 'array:name,username', ]);

一般来说，你应该总是指定允许出现在数组中的数组键。否则，验证器的 validate 和 validated 方法将返回所有经过验证的数据，包括数组及其所有键，即使这些键未经其他嵌套数组验证规则的验证。

验证嵌套数组输入

验证基于嵌套数组的表单输入字段并不一定是一件麻烦事。您可以使用“点符号”来验证数组内的属性。例如，如果传入的 HTTP 请求包含 photos[profile] 字段，您可以像这样验证它：

1
使用
照亮\支撑\外墙\
验证者
;
2
3
$验证器

=

验证者
::
制作
（
$请求
->
全部
（），[
4

‘
照片.个人资料
‘

=>

‘
必填|图片
‘
,
5
]);
使用 Illuminate\Support\Facades\Validator；$validator = Validator::make($request->all(), [ 'photos.profile' => 'required|image', ]);

您还可以验证数组的每个元素。例如，要验证给定数组输入字段中的每个电子邮件都是唯一的，您可以执行以下操作：

1
$验证器

=

验证者
::
制作
（
$请求
->
全部
（），[
2

‘
人.*.电子邮件
‘

=>

‘
电子邮件|唯一：用户
‘
,
3

‘
人.*.名字
‘

=>

‘
必填项：person.*.last_name
‘
,
4
]);
$validator = Validator::make($request->all(), [ 'person.*.email' => '电子邮件|unique:users', 'person.*.first_name' => 'required_with:person.*.last_name', ]);

同样，您可以使用 * 指定字符时语言文件中的自定义验证消息，使得对基于数组的字段使用单个验证消息变得轻而易举：

1
‘
风俗
‘

=>
[
2

‘
人.*.电子邮件
‘

=>
[
3

‘
独特的
‘

=>

‘
每个人都必须有一个唯一的电子邮件地址
‘
,
4
]
5
]，
'custom' => [ 'person.*.email' => [ 'unique' => '每个人都必须有一个唯一的电子邮件地址', ] ],

访问嵌套数组数据

有时，在为属性分配验证规则时，您可能需要访问给定嵌套数组元素的值。您可以使用 Rule::forEach 方法。这 forEach 方法接受一个闭包，该闭包将在验证下对数组属性的每次迭代中调用，并将接收属性的值和显式、完全展开的属性名称。闭包应返回一个规则数组以分配给数组元素：

1
使用
应用程序\规则\
有权限
;
2
使用
照亮\支撑\外墙\
验证者
;
3
使用
照亮\验证\
规则
;
4
5
$验证器

=

验证者
::
制作
（
$请求
->
全部
（），[
6

‘
公司.*.id
‘

=>

规则
::
forEach
（
功能

（
细绳
|
无效的

$值
,
细绳

$属性
）
{
7

返回
[
8

规则
::
存在
（
公司
::
班级
,
‘
ID
‘
),
9

新的

有权限
（
‘
管理公司
‘
,
$值
),
10
]；
11
}),
12
]);
使用 App\Rules\HasPermission；使用 Illuminate\Support\Facades\Validator；使用 Illuminate\Validation\Rule；$validator = Validator::make($request->all()，['companies.*.id' => Rule::forEach(function (string|null $value, string $attribute) {返回 [Rule::exists(Company::class,'id'),new HasPermission('manage-company',$value),];}),]);

错误消息索引和位置

验证数组时，您可能希望在应用程序显示的错误消息中引用验证失败的特定项目的索引或位置。为此，您可以包含 :index （从 0 ）和 :position （从 1 ）占位符自定义验证消息 :

1
使用
照亮\支撑\外墙\
验证者
;
2
3
$输入

=
[
4

‘
照片
‘

=>
[
5
[
6

‘
姓名
‘

=>

‘
海滩度假.jpg
‘
,
7

‘
描述
‘

=>

‘
我的海滩度假照片！
‘
,
8
]，
9
[
10

‘
姓名
‘

=>

‘
大峡谷.jpg
‘
,
11

‘
描述
‘

=>

“”
,
12
]，
13
]，
14
]；
15
16
验证者
::
证实
（
$输入
，[
17

‘
照片.*.描述
‘

=>

‘
必需的
‘
,
18
], [
19

‘
照片.*.说明.必填
‘

=>

‘
请描述照片编号：位置。
‘
,
20
]);
使用 Illuminate\Support\Facades\Validator; $input = [ 'photos' => [ [ 'name' => 'BeachVacation.jpg', 'description' => '我的海滩度假照片！', ], [ 'name' => 'GrandCanyon.jpg', 'description' => '', ], ], ]; Validator::validate($input, [ 'photos.*.description' => 'required', ], [ 'photos.*.description.required' => '请描述照片 #:位置。', ]);

鉴于上述示例，验证将失败，并且用户将看到以下错误 “请描述一下照片#2。”

如果需要，您可以通过以下方式引用更深层嵌套的索引和位置 second-index , second-position , third-index , third-position ， ETC。

1
‘
照片.*.属性.*.字符串
‘

=>

‘
照片 #:second-position 的属性无效。
‘
,
'photos.*.attributes.*.string' => '照片 #:second-position 的属性无效。',

验证文件

Laravel 提供了多种验证规则，可用于验证上传的文件，例如 mimes , image , min ，和 max 虽然您可以在验证文件时单独指定这些规则，但 Laravel 还提供了流畅的文件验证规则生成器，您可能会觉得很方便：

1
使用
照亮\支撑\外墙\
验证者
;
2
使用
照亮\验证\规则\
文件
;
3
4
验证者
::
证实
（
$输入
，[
5

‘
依恋
‘

=>
[
6

‘
必需的
‘
,
7

文件
::
类型
（[
‘
mp3
‘
,
‘
音频
‘
]）
8

->
分钟
（
1024
）
9

->
最大限度
（
12

*

1024
),
10
]，
11
]);
使用 Illuminate\Support\Facades\Validator；使用 Illuminate\Validation\Rules\File；Validator::validate($input，['attachment' => ['required'，File::types(['mp3', 'wav']) ->min(1024) ->max(12 * 1024), ], ]);

验证文件类型

尽管您只需要在调用时指定扩展 types 方法，该方法实际上通过读取文件的内容并猜测其 MIME 类型来验证文件的 MIME 类型。可以在以下位置找到 MIME 类型及其对应扩展名的完整列表：

https://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types

验证文件大小

为了方便起见，可以将最小和最大文件大小指定为带有表示文件大小单位的后缀的字符串。 kb , mb , gb ，和 tb 支持后缀：

1
文件
::
类型
（[
‘
mp3
‘
,
‘
音频
‘
]）
2

->
分钟
（
‘
1kb
‘
）
3

->
最大限度
（
‘
10兆
‘
（英文）：
文件::类型（['mp3'，'wav']）->最小（'1kb'）->最大（'10mb'）；

验证图像文件

要验证上传的文件是否为图像，您可以使用 File 规则的 image 构造函数方法。 File::image() 规则确保验证的文件是图像（jpg，jpeg，png，bmp，gif，svg或webp）：

1
使用
照亮\支撑\外墙\
验证者
;
2
使用
照亮\验证\
规则
;
3
使用
照亮\验证\规则\
文件
;
4
5
验证者
::
证实
（
$输入
，[
6

‘
照片
‘

=>
[
7

‘
必需的
‘
,
8

文件
::
图像
（），
9
]，
10
]);
使用 Illuminate\Support\Facades\Validator；使用 Illuminate\Validation\Rule；使用 Illuminate\Validation\Rules\File；Validator::validate($input, [ 'photo' => [ 'required', File::image(), ], ]);

验证图像尺寸

您还可以验证图片的尺寸。例如，要验证上传的图片宽度至少为 1000 像素，高度至少为 500 像素，您可以使用 dimensions 规则：

1
使用
照亮\验证\
规则
;
2
使用
照亮\验证\规则\
文件
;
3
4
文件
::
图像
（）
->
方面
（
5

规则
::
方面
（）
6

->
最大宽度
（
1000
）
7

->
最大高度
（
500
）
8
）
使用 Illuminate\Validation\Rule；使用 Illuminate\Validation\Rules\File；File::image()->dimensions(Rule::dimensions()->maxWidth(1000)->maxHeight(500))

有关验证图像尺寸的更多信息，请参阅尺寸规则文档。

验证密码

为了确保密码具有足够的复杂度，你可以使用 Laravel 的 Password 规则对象：

1
使用
照亮\支撑\外墙\
验证者
;
2
使用
照亮\验证\规则\
密码
;
3
4
$验证器

=

验证者
::
制作
（
$请求
->
全部
（），[
5

‘
密码
‘

=>
[
‘
必需的
‘
,
‘
确认的
‘
,
密码
::
分钟
（
8
)]，
6
]);
使用 Illuminate\Support\Facades\Validator；使用 Illuminate\Validation\Rules\Password；$validator = Validator::make($request->all(), [ 'password' => ['required', 'confirmed', Password::min(8)], ]);

这 Password 规则对象允许您轻松自定义应用程序的密码复杂性要求，例如指定密码至少需要一个字母、数字、符号或混合大小写的字符：

1
//
至少需要 8 个字符...
2
密码
::
分钟
（
8
）
3
4
//
至少需要一个字母...
5
密码
::
分钟
（
8
）
->
字母
（）
6
7
//
至少需要一个大写字母和一个小写字母...
8
密码
::
分钟
（
8
）
->
大小写混合
（）
9
10
//
至少需要一个数字...
11
密码
::
分钟
（
8
）
->
数字
（）
12
13
//
至少需要一个符号...
14
密码
::
分钟
（
8
）
->
符号
（）
// 至少需要 8 个字符... Password::min(8) // 至少需要有一个字母... Password::min(8)->letters() // 至少需要有一个大写字母和一个小写字母... Password::min(8)->mixedCase() // 至少需要有一个数字... Password::min(8)->numbers() // 至少需要有一个符号... Password::min(8)->symbols()

此外，您可以使用以下方式确保密码在公共密码数据泄露中没有被泄露： uncompromised 方法：

1
密码
::
分钟
（
8
）
->
不妥协
（）
密码::min(8)->uncompromised()

在内部， Password 规则对象使用 k-匿名模型来确定密码是否通过 haveibeenpwned.com 服务，同时又不牺牲用户的隐私或安全。

默认情况下，如果密码在数据泄露中至少出现一次，则将被视为泄露。您可以使用 uncompromised 方法：

1
//
确保在同一次数据泄露中密码出现的次数少于3次......
2
密码
::
分钟
（
8
）
->
不妥协
（
3
（英文）：
// 确保密码在同一次数据泄露中出现的次数少于 3 次...Password::min(8)->uncompromised(3);

当然，你可以链接上面示例中的所有方法：

1
密码
::
分钟
（
8
）
2

->
字母
（）
3

->
大小写混合
（）
4

->
数字
（）
5

->
符号
（）
6

->
不妥协
（）
密码::min(8) ->letters() ->mixedCase() ->numbers() ->symbols() ->uncompromised()

定义默认密码规则

您可能会发现在应用程序的单个位置指定密码的默认验证规则很方便。您可以使用 Password::defaults 方法，它接受一个闭包。传递给 defaults 方法应返回密码规则的默认配置。通常， defaults 规则应该在 boot 您的某个应用程序服务提供商的方法：

1
使用
照亮\验证\规则\
密码
;
2
3
/**
4
* 引导任何应用服务。
5

*/
6
民众

功能

引导
（）
:

空白
7
{
8

密码
::
默认值
（
功能

（）
{
9

$规则

=

密码
::
分钟
（
8
（英文）：
10
11

返回

$this
->应用程序->
是生产
（）
12

？

$规则
->
大小写混合
（）
->
不妥协
（）
13

:

$规则
;
14
});
15
}
使用 Illuminate\Validation\Rules\Password; /** * 引导任何应用服务。 */ public function boot(): void { Password::defaults(function () { $rule = Password::min(8); return $this->app->isProduction() ? $rule->mixedCase()->uncompromised() : $rule; }); }

然后，当你想将默认规则应用于正在验证的特定密码时，你可以调用 defaults 没有参数的方法：

1
‘
密码
‘

=>
[
‘
必需的
‘
,
密码
::
默认值
（）]，
'password' => ['必填', 密码::defaults()],

有时，您可能希望将其他验证规则附加到默认密码验证规则中。您可以使用 rules 实现此目的的方法：

1
使用
应用程序\规则\
规则
;
2
3
密码
::
默认值
（
功能

（）
{
4

$规则

=

密码
::
分钟
（
8
）
->
规则
（[
新的

规则
]);
5
6

//
...
7
});
使用 App\Rules\ZxcvbnRule；密码::defaults(function () { $rule = Password::min(8)->rules([new ZxcvbnRule]); // ... });

自定义验证规则

使用规则对象

Laravel 提供了各种有用的验证规则；但是，您可能希望指定一些自己的规则。注册自定义验证规则的一种方法是使用规则对象。要生成新的规则对象，您可以使用 make:rule Artisan 命令。让我们使用此命令生成一条规则，用于验证字符串是否为大写。Laravel 会将新规则放在 app/Rules 目录。如果此目录不存在，Laravel 将在您执行 Artisan 命令创建规则时创建它：

1
php
工匠

制定：规则

大写
php artisan make：规则大写

一旦创建了规则，我们就可以定义其行为了。规则对象包含一个方法： validate 该方法接收属性名称、属性值以及在验证失败时应调用的回调函数并显示验证错误消息：

1
2
3
命名空间
应用程序\规则；
4
5
使用

关闭
;
6
使用
阐明\合同\验证\
有效性规则
;
7
8
班级

大写

实现

有效性规则
9
{
10

/**
11
* 运行验证规则。
12

*/
13

民众

功能

证实
（
细绳

$属性
,
混合

$值
,
关闭

$失败
）
:

空白
14
{
15

如果
（
字符串上部
($
价值
）
!==

$值
）{
16

$失败
（
‘
:attribute 必须是大写。
‘
（英文）：
17
}
18
}
19
}

一旦定义了规则，您就可以通过传递规则对象的实例和其他验证规则将其附加到验证器：

1
使用
应用程序\规则\
大写
;
2
3
$请求
->
证实
（[
4

‘
姓名
‘

=>
[
‘
必需的
‘
,
‘
细绳
‘
,
新的

大写
]，
5
]);
使用 App\Rules\Uppercase; $request->validate([ 'name' => ['required', 'string', new Uppercase], ]);

翻译验证信息

而不是向 $fail 闭包，你也可以提供一个翻译字符串键并指示 Laravel 翻译错误消息：

1
如果
（
字符串上部
($
价值
）
!==

$值
）{
2

$失败
（
‘
验证.大写
‘
）
->
翻译
（）；
3
}
如果 (strtoupper($value) !== $value) { $fail('validation.uppercase')->translate(); }

如果需要，你可以提供占位符替换和首选语言作为 translate 方法：

1
$失败
（
‘
验证.位置
‘
）
->
翻译
（[
2

‘
价值
‘

=>

$this
->值
,
3
]，
‘
法国
‘
）
$fail('validation.location')->translate([ 'value' => $this->value, ], 'fr')

访问其他数据

如果你的自定义验证规则类需要访问所有其他正在验证的数据，那么你的规则类可以实现 Illuminate\Contracts\Validation\DataAwareRule 接口。此接口要求您的类定义一个 setData 方法。Laravel 将自动调用此方法（在验证进行之前），并验证所有需要验证的数据：

1
2
3
命名空间
应用程序\规则；
4
5
使用
阐明\合同\验证\
数据感知规则
;
6
使用
阐明\合同\验证\
有效性规则
;
7
8
班级

大写

实现

数据感知规则
,
有效性规则
9
{
10

/**
11
* 所有数据均在验证之中。
12
*
13
*
@我们的

大批
<
细绳
, 混合>
14

*/
15

受保护

$数据

=
[]；
16
17

//
...
18
19

/**
20
* 设置验证下的数据。
21
*
22
*
@参数

大批
<
细绳
, 混合 > $数据
23

*/
24

民众

功能

设置日期
（
大批

$数据
）
:

静止的
25
{
26

$this
->数据

=

$数据
;
27
28

返回

$this
;
29
}
30
}
 */ protected $data = []; // ... /** * 设置验证下的数据。 * * @param array $data */ public function setData(array $data): static { $this->data = $data; return $this; } }

或者，如果你的验证规则需要访问执行验证的验证器实例，你可以实现 ValidatorAwareRule 界面：

1
2
3
命名空间
应用程序\规则；
4
5
使用
阐明\合同\验证\
有效性规则
;
6
使用
阐明\合同\验证\
ValidatorAwareRule
;
7
使用
照亮\验证\
验证者
;
8
9
班级

大写

实现

有效性规则
,
ValidatorAwareRule
10
{
11

/**
12
* 验证器实例。
13
*
14
*
@我们的

\
照亮
\
验证
\
验证者
15

*/
16

受保护

$验证器
;
17
18

//
...
19
20

/**
21
* 设置当前验证器。
22

*/
23

民众

功能

设置验证器
（
验证者

$验证器
）
:

静止的
24
{
25

$this
->验证器

=

$验证器
;
26
27

返回

$this
;
28
}
29
}
validator = $validator; return $this; } }

使用闭包

如果在整个应用程序中只需要一次自定义规则的功能，则可以使用闭包而不是规则对象。闭包接收属性的名称、属性的值以及 $fail 验证失败时应调用的回调：

1
使用
照亮\支撑\外墙\
验证者
;
2
使用

关闭
;
3
4
$验证器

=

验证者
::
制作
（
$请求
->
全部
（），[
5

‘
标题
‘

=>
[
6

‘
必需的
‘
,
7

‘
最大：255
‘
,
8

功能

（
细绳

$属性
,
混合

$值
,
关闭

$失败
）
{
9

如果
（
$值

===

‘
富
‘
）{
10

$失败
（
“
这 {
$属性
} 无效。
“
（英文）：
11
}
12
}，
13
]，
14
]);
使用 Illuminate\Support\Facades\Validator；使用 Closure；$validator = Validator::make($request->all(), [ 'title' => [ 'required', 'max:255', function (string $attribute, hybrid $value, Closure $fail) { if ($value === 'foo') { $fail("{$attribute} 无效。"); } }, ], ]);

隐含规则

默认情况下，当要验证的属性不存在或包含空字符串时，不会运行常规验证规则（包括自定义规则）。例如， unique 规则不会针对空字符串运行：

1
使用
照亮\支撑\外墙\
验证者
;
2
3
$规则

=
[
‘
姓名
‘

=>

‘
唯一：用户，名称
‘
]；
4
5
$输入

=
[
‘
姓名
‘

=>

“”
]；
6
7
验证者
::
制作
（
$输入
,
$规则
）
->
通行证
（）；
//
真的
使用 Illuminate\Support\Facades\Validator；$rules = ['name' => 'unique:users,name']；$input = ['name' => '']；Validator::make($input, $rules)->passes()；// true

即使属性为空，自定义规则仍会运行，规则必须暗示该属性是必需的。要快速生成新的隐式规则对象，您可以使用 make:rule Artisan 命令 --implicit 选项：

1
php
工匠

制定：规则

大写

--隐式
php artisan make：规则大写--implicit

仅“隐含”规则隐含该属性是必需的。它是否真正使缺失或空的属性无效取决于您。

序幕

入门

架构概念

基础知识

深入挖掘

安全

数据库

Eloquent ORM

测试

套餐

验证

第一次验证失败时停止

布尔值

字符串

数字

数组

日期

文件

数据库

实用工具