validation du formulaire


~

Validation du formulaire

Introduction

Laravel propose plusieurs façons différentes de valider les données transmises dans votre application. Par défaut, les classes de base du contrôleur de Laravel utilisent ValidatesRequests Traits, qui fournissent un moyen pratique de valider les requêtes HTTP entrantes à l'aide d'une variété de règles de validation puissantes.

Validation rapide

Pour comprendre les puissantes capacités de validation de Laravel, examinons un exemple complet de validation d'un formulaire et d'affichage d'un message d'erreur à l'utilisateur.

Définir les routes

Tout d'abord, supposons que les routes suivantes soient définies dans le fichier routes/web.php : routes/web.php 文件中定义了下面这些路由：

Route::get('post/create', 'PostController@create');
Route::post('post', 'PostController@store');

显然，GET 路由会显示一个供用户创建一个新的博客帖子的表单，而 POST 路由会将新的博客文章存储在数据库中。

创建路由器

下面让我们一起来看看处理这些路由的控制器， store 方法暂时留空。

<?php
  namespace App\Http\Controllers;
  use Illuminate\Http\Request;
  use App\Http\Controllers\Controller;
  class PostController extends Controller{    
      /**
     * 显示创建博客文章的表单。
     *
     * @return Response
     */   
  public function create()   
   {       
    return view('post.create');    
    }   
     /**
     * 保存一篇新的博客文章。
     *
     * @param  Request  $request
     * @return Response
     */   
    public function store(Request $request)   
     {      
       // 验证并存储博客文章...   
      }
   }

编写验证器逻辑

现在我们开始在 store 方法中编写逻辑来验证新的博客文章。为此，我们将使用 IlluminateHttpRequest 对象提供的 validate 方法 。如果验证通过，代码就可以正常的运行。如果验证失败，则会抛出异常，并自动将对应的错误响应返回给用户。在典型的 HTTP 请求的情况下，会生成一个重定向响应，而对于 AJAX 请求则会发送 JSON 响应。

让我们接着回到 store 方法来深入理解 validate 方法：

/**
 * 保存一篇新的博客文章。
 *
 * @param  Request  $request
 * @return Response
 */
 public function store(Request $request){ 
    $validatedData = $request->validate([      
      'title' => 'required|unique:posts|max:255',        
      'body' => 'required',    
    ]);    
    // 博客文章验证通过
  }

如你所见，我们将所需的验证规则传递至 validate 方法中。另外再提醒一次，如果验证失败，会自动生成一个对应的响应。如果验证通过，那我们的控制器将会继续正常运行。

首次验证失败后停止运行

如果你希望在某个属性第一次验证失败后停止运行验证规则，你需要附加 bail 规则到该属性：

$request->validate([   
 'title' => 'bail|required|unique:posts|max:255',    
 'body' => 'required',
]);

在这个例子中，如果 title 字段没有通过 unique 规则，那么程序就不会继续检查 max

$request->validate([   
 'title' => 'required|unique:posts|max:255',    
 'author.name' => 'required',    
 'author.description' => 'required',
]);

Évidemment, GET affichera un formulaire permettant à l'utilisateur de créer un nouvel article de blog, tandis que la route POST stockera le nouvel article de blog dans la base de données.

Création d'un routeur

Voyons comment gérer ces routes Contrôleur, la méthode store est temporairement laissée vide. 

<!-- /resources/views/post/create.blade.php -->
<h1>创建文章</h1>
@if ($errors->any())  
  <div class="alert alert-danger">     
     <ul>
       @foreach ($errors->all() as $error)                
       <li>{{ $error }}</li>
            @endforeach
      </ul>    
   </div>
 @endif
 <!-- 创建文章表单 -->

🎜🎜Écrire la logique du validateur🎜🎜Maintenant, nous commençons dans store pour valider les nouveaux articles de blog. Pour ce faire, nous utiliserons la méthode validate fournie par l'objet IlluminateHttpRequest. Si la vérification réussit, le code peut s'exécuter normalement. Si la vérification échoue, une exception sera levée et la réponse d'erreur correspondante sera automatiquement renvoyée à l'utilisateur. Dans le cas d'une requête HTTP typique, une réponse de redirection est générée, tandis que pour les requêtes AJAX, une réponse JSON est envoyée. 🎜🎜Retournons sur la méthode store pour comprendre en profondeur la méthode validate : 🎜
$request->validate([  
  'title' => 'required|unique:posts|max:255',    
  'body' => 'required',    
  'publish_at' => 'nullable|date',
]);
🎜Comme vous pouvez le constater, nous transmettons les règles de validation requises pour valider méthode. De plus, encore une fois, si la vérification échoue, une réponse correspondante sera automatiquement générée. Si la vérification réussit, notre contrôleur continuera à fonctionner normalement. 🎜
🎜🎜Arrêter l'exécution après le premier échec de validation🎜🎜Si vous souhaitez arrêter d'exécuter des règles de validation après un premier échec de validation d'une propriété, vous devez ajouter bail à cet attribut : 🎜
php artisan make:request StoreBlogPost
🎜Dans cet exemple, si le champ title ne passe pas la règle unique, alors le programme ne continuera pas à vérifiez la règle max. Les règles sont vérifiées dans l'ordre dans lequel elles sont attribuées. 🎜🎜🎜🎜Remarque sur l'implémentation des données de tableau🎜🎜Si votre requête HTTP contient un paramètre "imbriqué" (c'est-à-dire un tableau), alors vous pouvez spécifier ces paramètres via la syntaxe "point" dans la règle de validation. 🎜
/**
 * 获取适用于请求的验证规则。
 *
 * @return array
 */
 public function rules(){   
  return [       
    'title' => 'required|unique:posts|max:255',        
    'body' => 'required',    
    ];
  }
🎜🎜🎜🎜🎜🎜

Afficher le message d'erreur de validation

Que se passe-t-il si les paramètres de la demande entrante ne satisfont pas aux règles de validation données ? Comme mentionné précédemment, Laravel redirige automatiquement l'utilisateur vers l'emplacement précédent. De plus, tous les messages d'erreur de validation seront automatiquement stockés en session. session 中。

重申一次，我们不必在 GET 路由中将错误消息显式绑定到视图。因为 Lavarel 会检查在 Session 数据中的错误信息，并自动将其绑定到视图（如果这个视图文件存在）。而其中的变量 $errors 是 IlluminateSupportMessageBag 的一个实例。要获取关于这个对象的更多信息，请  查阅这个文档 。

{tip} $errors 变量被 Web 中间件组提供的 IlluminateViewMiddlewareShareErrorsFromSession 中间件绑定到视图中。 当这个中间件被应用后，在你的视图中就可以获取到 $error 变量 , 可以使一直假定 $errors 变量存在并且可以安全地使用。

在上面的例子中，当验证失败的时候，用户将会被重定向到控制器的 create 方法，使我们能在视图中显示错误信息：

/**
 * 存储传入的博客文章。
 *
 * @param  StoreBlogPost  $request
 * @return Response
 */
 public function store(StoreBlogPost $request){   
  // 传入的请求通过验证...    
  // 获取通过验证的数据...    
  $validated = $request->validated();
 }

关于可选字段的注意事项

默认情况下，在 Laravel 应用的全局中间件堆栈 AppHttpKernel 类中包含了 TrimStrings 和 ConvertEmptyStringsToNull 中间件。因此，如果你不希望验证程序将 null 值视为无效的话，那就需要将「可选」的请求字段标记为 nullable，举个例子：

/**
 *  配置验证器实例。
 *
 * @param  \Illuminate\Validation\Validator  $validator
 * @return void
 */
 public function withValidator($validator){ 
    $validator->after(function ($validator) {        
         if ($this->somethingElseIsInvalid()) {           
              $validator->errors()->add('field', 'Something is wrong with this field!');        
             }   
         });
   }

在这个例子里，我们指定 publish_at 字段可以为 null 或者一个有效的日期格式。如果 nullable 的修饰词没有被添加到规则定义中，验证器会认为 null 是一个无效的日期格式。

AJAX 请求 & 验证

在这个例子中，我们使用传统的表单将数据发送到应用程序。但实际情况中，很多程序都会使用 AJAX 来发送请求。当我们对 AJAX 的请求中使用 validate

Encore une fois, nous n'avons pas besoin de lier explicitement le message d'erreur à la vue dans la route GET. Parce que Lavarel vérifiera les informations d'erreur dans les données de session et les liera automatiquement à la vue (si le fichier de vue existe). La variable $errors est une instance de IlluminateSupportMessageBag. Pour plus d'informations sur cet objet, veuillez consulter cette documentation .

{tip} La variable $errors est liée à la vue par le middleware IlluminateViewMiddlewareShareErrorsFromSession fourni par le groupe de middleware Web. Lorsque ce middleware est appliqué, la variable $error peut être obtenue à votre avis, ce qui peut toujours supposer que la variable $errors existe. est sûr à utiliser.

Dans l'exemple ci-dessus, lorsque la validation échoue, l'utilisateur sera redirigé vers la méthode create du contrôleur, permettant d'afficher le message d'erreur dans la vue : 
/**
 * 判断用户是否有权限做出此请求。
 *
 * @return bool
 */
 public function authorize(){  
   $comment = Comment::find($this->route('comment'));    
   return $comment && $this->user()->can('update', $comment);
 }

Note sur les champs facultatifs

Par défaut, dans La pile middleware globale pour les applications Laravel, la classe AppHttpKernel contient les middlewares TrimStrings et ConvertEmptyStringsToNull. Par conséquent, si vous ne souhaitez pas que le validateur traite les valeurs null comme invalides, vous devez marquer le champ de requête "facultatif" comme nullable, par exemple : 
Route::post('comment/{comment}');
Dans cet exemple, nous spécifions que le champ publish_at peut être null ou un format de date valide. Si le qualificatif nullable n'est pas ajouté à la définition de la règle, le validateur considérera null comme un format de date non valide. 🎜🎜🎜🎜
🎜

Requêtes et validation AJAX

🎜Dans ce Dans cet exemple, nous utilisons un formulaire traditionnel pour envoyer des données à l'application. Mais en réalité, de nombreux programmes utilisent AJAX pour envoyer des requêtes. Lorsque nous utilisons la méthode validate dans une requête AJAX, Laravel ne génère pas de réponse de redirection, mais génère à la place une réponse JSON contenant toutes les informations d'erreur de validation. Cette réponse JSON sera envoyée avec un code d'état HTTP 422. 🎜🎜🎜🎜🎜🎜🎜🎜Demande de formulaire de vérification🎜🎜🎜🎜🎜🎜🎜

Créer une vérification de demande de formulaire

Face à des scénarios de vérification plus complexes, vous pouvez créer une « demande de formulaire » pour gérer une logique plus complexe. Les requêtes de formulaire sont des classes de requêtes personnalisées qui contiennent une logique de validation. Vous pouvez utiliser la commande Artisan make:request pour créer une classe de requête de formulaire : make:request 来创建表单请求类：

/**
 * 判断用户是否有权限进行此请求。
 *
 * @return bool
 */
 public function authorize(){  
   return true;
  }

新生成的类保存在 app/Http/Requests 目录下。如果这个目录不存在，运行 make:request 命令时它会被创建出来。让我们添加一些验证规则到 rules 方法中：

/**
 * 获取已定义验证规则的错误消息。
 *
 * @return array
 */
 public function messages(){  
   return [       
    'title.required' => 'A title is required',        
    'body.required'  => 'A message is required',    
    ];
  }

{tip} 你可以向 rules 方法传入所需的任何依赖项。他们会自动被 Laravel 提供的 服务容器 自动解析。

验证规则是如何运行的呢？你所需要做的就是在控制器方法中类型提示传入的请求。在调用控制器方法之前验证传入的表单请求，这意味着你不需要在控制器中写任何验证逻辑：

/**
 * 获取验证错误的自定义属性。
 *
 * @return array
 */
 public function attributes(){  
   return [      
     'email' => 'email address',    
     ];
   }

如果验证失败，就会生成一个让用户返回到先前的位置的重定向响应。这些错误也会被闪存到 session 中，以便这些错误都可以在页面中显示出来。如果传入的请求是 AJAX，会向用户返回具有 422 状态代码和验证错误信息的 JSON 数据的 HTTP 响应。

添加表单请求后钩子

如果你想在表单请求「之后」添加钩子，可以使用 withValidator 方法。这个方法接收一个完整的验证构造器，允许你在验证结果返回之前调用任何方法：

<?php
   namespace App\Http\Controllers;use Validator;
   use Illuminate\Http\Request;
   use App\Http\Controllers\Controller;
   class PostController extends Controller{    
      /**
     * 保存一篇新的博客文章。
     *
     * @param  Request  $request
     * @return Response
     */   
    public function store(Request $request)   
     {       
      $validator = Validator::make($request->all(), [      
            'title' => 'required|unique:posts|max:255',            
            'body' => 'required',        
          ]);       
        if ($validator->fails()) {          
          return redirect('post/create')                       
           ->withErrors($validator)                        
           ->withInput();       
           }       
       // Store the blog post...  
        }
      }

表单请求授权验证

表单请求类内也包含了 authorize 方法。在这个方法中，你可以检查经过身份验证的用户确定其是否具有更新给定资源的权限。比方说，你可以判断用户是否拥有更新文章评论的权限：

Validator::make($request->all(), [   
 'title' => 'required|unique:posts|max:255',    
 'body' => 'required',
])->validate();

由于所有的表单请求都是继承了 Laravel 中的请求基类，所以我们可以使用 user 方法去获取当前认证登录的用户。同时请注意上述例子中对 route 方法的调用。这个方法允许你在被调用的路由上获取其定义的 URI 参数，譬如下面例子中的 {comment} 参数：

return redirect('register')          
  ->withErrors($validator, 'login');

如果 authorize 方法返回 false，则会自动返回一个包含 403 状态码的 HTTP 响应，也不会运行控制器的方法。

如果你打算在应用程序的其它部分处理授权逻辑，只需从 authorize 方法返回 true：

{{ $errors->login->first('email') }}

{tip} 你可以向 authorize

$validator = Validator::make(...);$validator->after(function ($validator) {   
 if ($this->somethingElseIsInvalid()) {     
    $validator->errors()->add('field', 'Something is wrong with this field!');   
     }
   });
 if ($validator->fails()) {  
   //
 }

La classe nouvellement générée est enregistrée dans le répertoire app/Http/Requests. Si ce répertoire n'existe pas, il sera créé lors de l'exécution de la commande make:request. Ajoutons quelques règles de validation à la méthode rules : 
$errors = $validator->errors();echo $errors->first('email');

{tip} Vous pouvez transmettre toutes les dépendances que vous souhaitez à la méthode rules. Ils seront automatiquement résolus par le conteneur de services fourni par Laravel.

Comment fonctionnent les règles de validation ? Tout ce que vous avez à faire est de taper un indice sur la requête entrante dans la méthode du contrôleur. Validez la demande de formulaire entrante avant d'appeler la méthode du contrôleur, ce qui signifie que vous n'avez pas besoin d'écrire de logique de validation dans le contrôleur : 
foreach ($errors->get('email') as $message) {  
  //
}
Si la validation échoue, une réponse de redirection est générée qui ramène l'utilisateur à l'emplacement précédent. Ces erreurs sont également flashées dans session afin qu'elles puissent être affichées sur la page. Si la requête entrante est AJAX, une réponse HTTP de données JSON avec un code d'état 422 et des informations d'erreur de validation est renvoyée à l'utilisateur. 🎜
🎜

Ajouter un hook après la demande de formulaire

🎜Si vous souhaitez ajouter un hook "après" la demande de formulaire, vous pouvez utiliser méthode withValidator. Cette méthode accepte un constructeur de validation complet, vous permettant d'appeler n'importe quelle méthode avant que les résultats de validation ne soient renvoyés : 🎜
foreach ($errors->get('attachments.*') as $message) { 
   //
}
🎜🎜🎜
🎜🎜Vérification de l'autorisation de demande de formulaire🎜🎜La classe de demande de formulaire contient également la méthode authorize. Dans cette méthode, vous pouvez vérifier l'utilisateur authentifié pour déterminer s'il est autorisé à mettre à jour la ressource donnée. Par exemple, vous pouvez déterminer si l'utilisateur a l'autorisation de mettre à jour les commentaires de l'article : 🎜
foreach ($errors->all() as $message) { 
   //
}
🎜Étant donné que toutes les requêtes de formulaire héritent de la classe de base de requête dans Laravel, nous pouvons utiliser la méthode user pour obtenir l'authentification actuelle. utilisateurs connectés. Veuillez également noter l'appel à la méthode route dans l'exemple ci-dessus. Cette méthode permet d'obtenir les paramètres URI définis sur la route appelée, comme le paramètre {comment> dans l'exemple suivant : 🎜
if ($errors->has('email')) { 
   //
}
🎜Si la méthode authorize renvoie < code >false, une réponse HTTP contenant un code d'état 403 sera automatiquement renvoyée et la méthode du contrôleur ne sera pas exécutée. 🎜🎜Si vous envisagez de gérer la logique d'autorisation dans d'autres parties de l'application, renvoyez simplement true à partir de la méthode authorize : 🎜
$messages = [  
  'required' => 'The :attribute field is required.',
 ];
 $validator = Validator::make($input, $rules, $messages);
🎜{tip} Vous pouvez Ask < La méthode code>authorize transmet toutes les dépendances requises. Ils seront automatiquement résolus par le conteneur de services fourni par Laravel. 🎜🎜🎜🎜🎜🎜🎜🎜

Messages d'erreur personnalisés

Vous pouvez personnaliser les messages d'erreur en remplaçant la méthode messages de la demande de formulaire. Cette méthode doit renvoyer un tableau de paires attribut/règle et leurs messages d'erreur correspondants : messages 方法来自定义错误消息。此方法应返回属性 / 规则对数组及其对应错误消息：

$messages = [   
 'same'=> 'The :attribute and :other must match.',    
 'size'=> 'The :attribute must be exactly :size.',    
 'between' => 'The :attribute value :input is not between :min - :max.',    
 'in'=> 'The :attribute must be one of the following types: :values',
];

自定义验证属性

如果你希望将验证消息的 :attribute 部分替换为自定义属性名称，则可以重写 attributes 方法来指定自定义名称。此方法应返回属性 / 名称对的数组：

$messages = [ 
   'email.required' => 'We need to know your e-mail address!',
 ];

手动创建验证器

如果你不想在请求上使用 validate 方法，你可以通过 Validator facade 手动创建一个验证器示例。
用 Validator facade 上的 make 方法创建一个验证器示例：

'custom' => [  
  'email' => [    
      'required' => 'We need to know your e-mail address!',  
      ],
    ],

传给 make 方法的第一个参数是需要验证的数据。第二个参数则是该数据的验证规则。

如果验证失败，则可以使用 withErrors 方法把错误消息闪存到 Session 。使用这个方法进行重定向后， $errors 变量会自动和视图共享，你可以把这些消息显示给用户。 withErrors 方法接收验证器、MessageBag 或 PHP Array 。

自动重定向

如果你想手动创建验证器实例，又想使用 validates 方法提供的自动重定向，那么你可以在现有的验证器示例上调用 validate 方法。如果验证失败，用户将会自动重定向。在 AJAX 请求中，则会返回 JSON 格式的响应。

'attributes' => [  
  'email' => 'email address',
 ],

命名错误包

如果你一个页面中有多个表单，你可以通过命名错误包来检索特定表单的错误消息。只需给 withErrors 方法传递一个名字作为第二个参数

$request->validate([  
  'credit_card_number' => 'required_if:payment_type,cc'
 ]);

然后你就可以从 $errors 变量中获取指定表单的错误消息：

    当payment type为cc时，credit card number 不能为空。

验证后钩子

验证器还允许你添加在验证成功之后允许的回调函数，以便你进行下一步的验证，甚至在消息集合中添加更多的错误消息。使用它只需在验证实例上使用 after

'values' => [ 
   'payment_type' => [    
       'cc' => '信用卡' 
        ],
    ],

Attributs de validation personnalisés
Si vous souhaitez remplacer la partie :attribute du message de validation par un nom d'attribut personnalisé, vous pouvez remplacer la méthode attributes pour spécifier un nom personnalisé. Cette méthode doit renvoyer un tableau de paires propriété/nom : 🎜
    当payment type 为信用卡时，credit card number不能为空。
🎜🎜🎜
🎜

Création manuelle validations Validator

🎜Si vous ne souhaitez pas utiliser la méthode validate sur la requête, vous pouvez créer manuellement un exemple de validateur via la façade Validator.
Créez un exemple de validateur en utilisant la méthode make sur la façade Validator : 🎜
'start_date' => 'required|date|after:tomorrow'
🎜Le premier argument passé à la méthode make est données qui doivent être vérifiées. Le deuxième paramètre est la règle de validation des données. 🎜🎜Si la validation échoue, vous pouvez utiliser la méthode withErrors pour flasher le message d'erreur sur la session. Après la redirection à l'aide de cette méthode, la variable $errors sera automatiquement partagée avec la vue et vous pourrez afficher ces messages à l'utilisateur. La méthode withErrors reçoit un validateur, un MessageBag ou un Array PHP. 🎜🎜🎜🎜
🎜🎜Redirection automatique🎜🎜Si vous souhaitez créer l'instance de validateur manuellement et que vous souhaitez utiliser validates fournit une redirection automatique, vous pouvez alors appeler la méthode validate sur un exemple de validateur existant. Si la vérification échoue, l'utilisateur sera automatiquement redirigé. Dans une requête AJAX, une réponse au format JSON est renvoyée. 🎜
'finish_date' => 'required|date|after:start_date'
🎜🎜🎜
🎜🎜Sacs d'erreur nommés🎜🎜Si vous avez plusieurs formulaires sur une page, vous les messages pour un formulaire spécifique peuvent être récupérés en nommant le package d’erreurs. Passez simplement un nom comme deuxième argument à la méthode withErrors 🎜
'avatar' => 'dimensions:min_width=100,min_height=200'
🎜 et vous pourrez ensuite obtenir le message d'erreur pour le formulaire spécifié à partir de la variable $errors : 🎜
'avatar' => 'dimensions:ratio=3/2'
🎜 < a name="after-validation-hook">🎜🎜
🎜🎜Hook post-validation🎜🎜Le validateur vous permet également d'ajouter des fonctions de rappel autorisées après validation réussie, cela vous permet d'effectuer une vérification plus approfondie et même d'ajouter plus de messages d'erreur à la collection de messages. Pour l'utiliser utilisez simplement la méthode after sur l'instance de validation : 🎜
use Illuminate\Validation\Rule;
Validator::make($data, [  
  'avatar' => [     
     'required',        
     Rule::dimensions()->maxWidth(1000)->maxHeight(500)->ratio(3 / 2),    
   ],
  ]);
🎜🎜🎜🎜🎜🎜

Gestion des messages d'erreur

Après avoir appelé la méthode errors sur l'instance Validator, vous obtiendrez une instance IlluminateSupportMessageBag, qui dispose de diverses méthodes pratiques. messages d'erreur. La variable $ error est automatiquement fournie à toutes les vues et est également une instance de la classe MessageBag. Validator 实例上调用 errors 方法后，你会得到一个 IlluminateSupportMessageBag 实例，它拥有各种方便的方法处理错误信息。自动提供给所有视图的 $ errors 变量，也是 MessageBag 类的一个实例。

查看特定字段的第一个错误信息

要查看特定字段的第一个错误消息，可以使用 first 方法：

'foo.*.id' => 'distinct'

查看特定字段的所有错误消息

如果你需要获取指定字段的所有错误消息的数组，则可以使用 get 方法：

'state' => 'exists:states'

如果要验证表单的数组字段，你可以使用 * 来获取每个数组元素的所有错误消息：

'state' => 'exists:states,abbreviation'

查看所有字段的所有错误消息

如果你想要得到所有字段的所有错误消息，可以使用 all 方法：

'email' => 'exists:connection.staff,email'

判断特定字段是否含有错误消息

has 方法可以被用来判断给定的字段是否存在错误信息:

use Illuminate\Validation\Rule;
Validator::make($data, [  
  'email' => [      
    'required',        
    Rule::exists('staff')->where(function ($query) {  
           $query->where('account_id', 1);    
        }),
     ],
  ]);

自定义错误消息

如果有需要的话，你也可以使用自定义错误消息取代默认值进行验证。有几种方法可以指定自定义消息。首先，你可以将自定义消息作为第三个参数传递给 Validator::make 方法：

use Illuminate\Validation\Rule;
Validator::make($data, [  
  'zones' => [      
    'required',        
    Rule::in(['first-zone', 'second-zone']),  
   ],
]);

在这个例子中，:attribute 占位符会被验证字段的实际名称取代。除此之外，你还可以在验证消息中使用其它占位符。例如：

'video' => 'mimetypes:video/avi,video/mpeg,video/quicktime'

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

有时候你可能只想为特定的字段自定义错误消息。只需在属性名称后使用「点」语法来指定验证的规则即可：

'photo' => 'mimes:jpeg,bmp,png'

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

在大多数情况下，您可能会在语言文件中指定自定义消息，而不是直接将它们传递给 Validator。为此，需要把你的消息放置于 resources/lang/xx/validation.php 语言文件内的 custom 数组中。

use Illuminate\Validation\Rule;
Validator::make($data, [  
  'toppings' => [     
     'required',        
     Rule::notIn(['sprinkles', 'cherries']), 
     ],
 ]);

在语言文件中指定自定义属性

如果你希望将验证消息的 :attribute 占位符替换为自定义属性名称，你可以在 resources/lang/xx/validation.php 语言文件的 attributes

Afficher le premier message d'erreur d'un champ spécifique

Pour afficher le premier message d'erreur d'un champ spécifique, vous pouvez utiliser première méthode : 
use Illuminate\Validation\Rule;
Validator::make($request->all(), [  
  'role_id' => Rule::requiredIf($request->user()->is_admin),]);
  Validator::make($request->all(), [   
   'role_id' => Rule::requiredIf(function () use ($request) {     
      return $request->user()->is_admin;   
      }),
    ]);
🎜

Afficher tous les messages d'erreur pour un champ spécifique

🎜Si vous avez besoin d'obtenir tous les messages d'erreur pour un champ Array spécifié, vous pouvez utiliser la méthode get : 🎜
'email' => 'unique:users,email_address'
🎜 Si vous souhaitez valider un champ tableau du formulaire, vous pouvez utiliser * pour obtenir toutes les erreurs messages pour chaque élément du tableau : 🎜 
'email' => 'unique:connection.users,email_address'
🎜

Afficher tous les messages d'erreur pour tous les champs

🎜Si vous souhaitez obtenir tous les messages d'erreur pour tous les champs , vous pouvez utiliser all Méthode : 🎜
use Illuminate\Validation\Rule;
Validator::make($data, [ 
   'email' => [      
     'required',        
     Rule::unique('users')->ignore($user->id),  
     ],
 ]);
🎜

Déterminer si un champ spécifique contient un message d'erreur

🎜< La méthode code>has peut être utilisée pour déterminer s'il y a un message d'erreur dans un champ donné : 🎜
Rule::unique('users')->ignore($user)
🎜🎜
🎜

Message d'erreur personnalisé

🎜Si nécessaire, vous pouvez également utiliser un message d'erreur personnalisé pour remplacer la valeur par défaut à des fins de vérification. Il existe plusieurs façons de spécifier un message personnalisé. Tout d'abord, vous pouvez transmettre un message personnalisé comme troisième paramètre à la méthode Validator::make : 🎜
Rule::unique('users')->ignore($user->id, 'user_id')
🎜Dans cet exemple, l'espace réservé :attribute sera Valider le message réel nom du champ à la place. De plus, vous pouvez utiliser d'autres espaces réservés dans le message de vérification. Par exemple : 🎜
Rule::unique('users', 'email_address')->ignore($user->id),
🎜

Spécifiez un message personnalisé pour un attribut donné

🎜Parfois, vous souhaiterez peut-être uniquement personnaliser le message d'erreur pour un attribut spécifique. champ . Utilisez simplement la syntaxe "point" après le nom de l'attribut pour spécifier les règles de validation : 🎜
'email' => Rule::unique('users')->where(function ($query) {  
  return $query->where('account_id', 1);
})
🎜🎜
🎜

Spécifier les messages personnalisés dans les fichiers de langue

🎜Dans la plupart des cas, vous spécifierez probablement des messages personnalisés dans les fichiers de langue plutôt que de les transmettre directement à Validator . Pour ce faire, placez votre message dans le tableau custom du fichier de langue resources/lang/xx/validation.php. 🎜
$v = Validator::make($data, [    'email' => 'sometimes|required|email',]);
🎜

Spécifiez les attributs personnalisés dans le fichier de langue

🎜Si vous souhaitez valider les espaces réservés :attribute du message sont remplacés par des noms d'attributs personnalisés que vous pouvez spécifier dans le tableau attributes du fichier de langue resources/lang/xx/validation.php : 🎜
$v = Validator::make($data, [  
  'email' => 'required|email',    
  'games' => 'required|numeric',
]);
🎜 🎜

Spécifiez des valeurs personnalisées dans les fichiers de langue

Parfois, il peut être nécessaire de remplacer l'espace réservé :value du message de validation par un littéral personnalisé pour la valeur. Par exemple, si la valeur de payment_type est cc, utilisez la règle de validation suivante, qui spécifie qu'un numéro de carte de crédit est requis : :value 占位符替换为值的自定义文字。例如，如果 payment_type 的值为 cc，使用以下验证规则，该规则指定需要信用卡号：

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

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

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

您可以通过定义 values 数组，在 validation 语言文件中指定自定义值表示，而不是显示 cc

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

Si cette règle de validation échoue, le message d'erreur suivant est généré :

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

Vous pouvez spécifier une représentation de valeur personnalisée dans le fichier de langue validation en définissant le tableau values au lieu d'afficher cc comme type de paiement Valeur : 

'custom' => [  
  'person.*.email' => [    
      'unique' => 'Each person must have a unique e-mail address',   
     ]
    ],
Désormais, si la règle de validation échoue, elle produira le message suivant : 
php artisan make:rule Uppercase

🎜🎜🎜

Règles de validation disponibles

Voici une liste de toutes les règles de validation disponibles et leurs fonctions :

Accepté
URL active
Après (Date)
Après ou égal (Date)
Alpha
Alpha Dash
Alpha Numeric
Array
Bail
Avant (Date)
Avant ou égal (Date)
Entre
Booléen
Confirmé
Date
Date égale
Format de date
Différent
Chiffres
Chiffres entre
Dimensions (fichiers image)
Distinct
E - Mail
Existe (Base de données)
Fichier
Rempli
Supérieur à
Supérieur ou égal
Image (Fichier)
Dans
Dans Tableau
Entier
IP Adresse
JSON
Moins Que
Inférieur ou égal
Max
Types MIME
Type MIME par extension de fichier
Min
Pas dans
Pas Regex
Nu llable
Numérique
Présent
Expression régulière
Obligatoire
Obligatoire si
Obligatoire sauf
Obligatoire avec
Obligatoire avec tous
Sans
Obligatoire sans tout
Idem
Taille
Comme par
Chaîne
Fuseau horaire
Unique (Base de données)
URL
UUID

accepté

Le champ de validation doit être oui, on, 1 ou true. Ceci est utile pour confirmer si vous acceptez les conditions d’utilisation.

active_url

Selon la fonction PHP dns_get_record, le champ de validation doit avoir un enregistrement A ou AAAA valide. dns_get_record，验证字段必须具有有效的 A 或 AAAA 记录。

after:date

验证字段必须是给定日期之后的值。日期值将传递到 PHP 函数 strtotime：

<?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.';   
       }
      }

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

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

after_or_equal:date

验证字段必须是在给定日期之后或与此日期相同的值。更多信息，请参阅 after 规则。

alpha

验证字段必须完全由字母构成。

alpha_dash

验证字段可能包含字母、数字，以及破折号 (-) 和下划线 ( _ )。

alpha_num

验证字段必须是完全是字母、数字。

array

验证的字段必须是一个 PHP 数组。

bail

在第一次验证失败后停止运行验证规则。

before:date

验证字段必须是在给定日期之前。这个日期值将会被传递给  PHP 的  strtotime 函数来计算。

before_or_equal:date

验证字段必须是在给定日期之前或与之相同的日期。这个日期值将会被传递给  PHP 的  strtotime 函数来计算。

between:min,max

验证字段的大小必须在给定的  min 和  max 之间。字符串、数字、数组和文件的计算方式都使用  size

after:

date
🎜Le champ de validation doit être une valeur postérieure à la date indiquée. La valeur de la date sera passée à la fonction PHP strtotime : 🎜
use App\Rules\Uppercase;$request->validate([  
  'name' => ['required', 'string', new Uppercase],
]);
🎜 Au lieu de passer une chaîne de date à traiter par strtotime vous pouvez spécifier un autre champ à comparer avec la date :🎜
$validator = Validator::make($request->all(), [   
 'title' => [      
   'required',        
   'max:255',        
   function ($attribute, $value, $fail) {          
     if ($value === 'foo') {              
       $fail($attribute.' is invalid.');      
             }      
            },    
          ],
        ]);
🎜🎜🎜
🎜🎜after_or_equal:🎜date🎜🎜🎜Le champ de validation doit être renseigné Une valeur postérieure ou identique à la date spécifiée. Pour plus d'informations, consultez la règle after🎜. 🎜🎜🎜🎜
🎜🎜alpha🎜🎜Le champ de validation doit être entièrement composé de lettres. 🎜🎜🎜🎜
🎜🎜alpha_dash🎜🎜Les champs de validation peuvent contenir des lettres, des chiffres et des tirets (-) et Souligner (_). 🎜🎜🎜🎜
🎜🎜alpha_num🎜🎜Le champ de validation doit être entièrement composé de lettres et de chiffres. 🎜🎜🎜🎜
🎜🎜array🎜🎜Le champ à vérifier doit être un tableau PHP. 🎜🎜🎜🎜
🎜🎜bail🎜🎜Arrêtez d'exécuter les règles de validation après le premier échec de validation. 🎜🎜🎜🎜
🎜🎜before:🎜date🎜🎜🎜Le champ de validation doit être antérieur à la date indiquée. Cette valeur de date sera transmise à la fonction strtotime de PHP pour le calcul. 🎜🎜🎜🎜
🎜🎜before_or_equal:🎜date🎜🎜🎜Le champ de validation doit être sur le donné date antérieure ou à la même date. Cette valeur de date sera transmise à la fonction strtotime de PHP pour le calcul. 🎜🎜🎜🎜
🎜🎜between:🎜min🎜,🎜max🎜🎜🎜La taille du champ de validation doit être dans la limite donnée entre 🎜min🎜 et 🎜max🎜. Les chaînes, les nombres, les tableaux et les fichiers sont calculés à l'aide de la méthode size🎜. 🎜🎜🎜🎜🎜🎜🎜

booléen

Le champ validé doit être convertible en type booléen. Les entrées acceptables sont true, false, 1, 0, "1", et "0". true, false, 1, 0, "1", 和 "0"。

confirmed

验证字段必须具有匹配字段 foo_confirmation。例如，验证字段为 password ，输入中必须存在与之匹配的 password_confirmation 字段。

date

根据 PHP 函数 strtotime，验证字段必须是有效的日期。

date_equals:date

验证字段必须等于给定日期。日期将传递到 PHP 函数 strtotime。

date_format:format

验证字段必须匹配给定的日期格式。当验证某个字段的时候，你应该 只使用 date 或者 date_format ，而不是同时使用。

different:field

验证字段必须具有与 field 不同的值。

digits:value

验证字段必须为 numeric ，且必须具有_value_的确切长度。

digits_between:min,max

验证的字段的长度必须在给定的  min 和  max 之间。

dimensions

验证中的文件必须是图片，并且符合指定的规则约束：

<?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()   
      {       
       //   
       }
     }

可用的约束为： min_width, max_width, min_height, max_height, width, height, ratio。

ratio 限制应该表示为宽度除以高度。 这可以通过使用像 3/2 的表达式 或者一个浮点数，像 1.5 来指定：

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

由于此规则需要多个参数，你可以使用 Rule::dimensions

confirmed
Le champ de validation doit avoir le champ correspondant foo_confirmation. Par exemple, si le champ de validation est password , un champ password_confirmation correspondant doit être présent dans l'entrée.

date

Selon la fonction PHP strtotime, la validation le champ doit être Date valide.

date_equals:date

Le champ de validation doit être égale à la date de réglage donnée. La date est passée à la fonction PHP strtotime.

🎜🎜date_format :format🎜🎜Le champ de validation doit correspondre format de date spécifique. Lors de la validation d'un champ, vous devez uniquement utiliser date ou date_format, pas les deux. 🎜🎜🎜🎜
🎜🎜différent :champ🎜🎜Le champ de validation doit avoir le même >champ différentes valeurs. 🎜🎜🎜🎜
🎜🎜chiffres :valeur🎜🎜Le champ de validation doit être numérique et doit avoir la longueur exacte de _value_. 🎜🎜🎜🎜
🎜🎜digits_between :min,max🎜🎜La longueur du champ à vérifier doit être comprise entre le min et le max donnés. 🎜🎜🎜🎜
🎜🎜dimensions🎜🎜Le fichier en cours de vérification doit être une image et respecter les contraintes des règles spécifiées : 🎜 
"foo" => "Your input was invalid!",
"accepted" => "The :attribute must be accepted.",
// 其余的验证错误消息...
🎜Les contraintes disponibles sont : min_width, max_width, min_height, max_height, width, hauteur, rapport. 🎜🎜ratio La limite doit être exprimée en largeur divisée par la hauteur. Cela peut être spécifié en utilisant une expression comme 3/2 ou un nombre à virgule flottante comme 1.5 : 🎜
/**
 * 启动应用程序。
 *
 * @return void
 */
 public function boot(){  
   Validator::extend(...);    
   Validator::replacer('foo', function ($message, $attribute, $rule, $parameters) {    
       return str_replace(...);  
      });
 }
🎜Étant donné que cette règle nécessite plusieurs paramètres, vous pouvez utiliser La méthode Rule::dimensions construit couramment des règles : 🎜
$rules = ['name' => 'unique'];
$input = ['name' => null];
Validator::make($input, $rules)->passes();
 // true
🎜🎜🎜🎜🎜🎜🎜distinct🎜🎜Lors de la validation d'un tableau, les champs de validation ne doivent contenir aucune valeur en double. 🎜
Validator::extendImplicit('foo', function ($attribute, $value, $parameters, $validator) { 
   return $value == 'foo';
  });
🎜🎜🎜🎜🎜🎜🎜email🎜🎜Le champ de validation doit être une adresse email correctement formatée. 🎜🎜🎜🎜🎜🎜🎜

exists:table,column

Les champs de validation doivent exister dans la table de base de données donnée.

Utilisation de base de la règle existante

rrreee

Si l'option colonne n'est pas spécifiée, le nom du champ sera utilisé. column 选项，则将使用字段名称。

指定自定义的表字段

rrreee

有时，你可能需要指定要用于「exists」查询的特定数据库连接。你可以使用「点」语法将连接名称添加到表名称前来完成此操作：

rrreee

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

rrreee

file

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

filled

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

gt:field

验证字段必须大于给定的 field。两个字段必须是相同的类型。字符串、数字、数组和文件都使用 size 进行相同的评估。

gte:field

验证字段必须大于或等于给定的  field。两个字段必须是相同的类型。字符串、数字、数组和文件都使用 size 进行相同的评估。

image

验证的文件必须是图片 (jpeg, png, bmp, gif, 或 svg)

in:foo,bar,...

验证字段必须包含在给定的值列表中。由于此规则通常要求您 implode 数组，因此可以使用 Rule :: in

Spécifier des champs de table personnalisésrrreeeParfois, vous devrez peut-être spécifier une connexion à la base de données spécifique à utiliser pour les requêtes "existe". Vous pouvez le faire en ajoutant le nom de la connexion au nom de la table en utilisant la syntaxe "point" :

rrreee
Si vous souhaitez personnaliser la requête effectuée par la règle de validation, vous pouvez utiliser la classe Rule pour définir il règne couramment. Dans l'exemple ci-dessous, nous spécifions également les règles de validation sous forme de tableau au lieu d'utiliser le caractère | pour les séparer :
rrreee

fichierLe champ vérifié doit être un fichier téléchargé avec succès.

rempli

Le champ de validation ne doit pas être vide lorsqu'il est présent.

gt:

field

Le champ de validation doit être supérieur au

field

donné . Les deux champs doivent être du même type. Les chaînes, les nombres, les tableaux et les fichiers sont tous évalués de manière identique en utilisant size.

gte:

field

Le champ de validation doit être supérieur ou égal à la valeur donnée

terrain

. Les deux champs doivent être du même type. Les chaînes, les nombres, les tableaux et les fichiers sont tous évalués de manière identique en utilisant size.

image
🎜Le fichier vérifié doit être une image (jpeg, png, bmp, gif, ou svg)🎜🎜🎜🎜
🎜🎜in:🎜foo🎜,🎜bar🎜,...🎜🎜validation champs Doit être contenu dans la liste de valeurs donnée. Puisque cette règle vous oblige généralement à imploder un tableau, vous pouvez utiliser la méthode Rule::in pour construire la règle de manière fluide : 🎜rrreee🎜🎜🎜🎜🎜🎜🎜in_array :🎜anotherfield🎜 🎜🎜Le champ en cours de validation doit exister dans la valeur d'un autre champ 🎜anotherfield🎜. 🎜🎜🎜🎜🎜🎜🎜🎜entier🎜🎜Le champ à vérifier doit être un entier. 🎜🎜🎜🎜🎜🎜🎜🎜ip🎜🎜Le champ à vérifier doit être l'adresse IP. 🎜🎜🎜🎜ipv4🎜🎜Le champ vérifié doit être une adresse IPv4. 🎜🎜🎜🎜ipv6🎜🎜Le champ vérifié doit être une adresse IPv6. 🎜🎜🎜🎜🎜🎜🎜

json

Le champ à vérifier doit être une chaîne JSON valide.

lt:field

Le champ en validation doit être plus petit que le champ donné. Les deux champs doivent être du même type. Les tailles de chaîne, numérique, tableau et fichier sont calculées et évaluées avec la méthode size. size 方法进行评估。

lte:field

验证中的字段必须小于或等于给定的字段。这两个字段必须是相同的类型。字符串、数值、数组和文件大小的计算方式与  size  方法进行评估。

max:value

验证中的字段必须小于或等于 value。字符串、数字、数组或是文件大小的计算方式都用 size 方法进行评估。

mimetypes:text/plain,...

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

rrreee

要确定上传文件的 MIME 类型，会读取文件的内容来判断 MIME 类型，这可能与客户端提供的 MIME 类型不同。

mimes:foo,bar,...

验证的文件必须具有与列出的其中一个扩展名相对应的 MIME 类型。

MIME 规则基本用法

rrreee

即使你可能只需要验证指定扩展名，但此规则实际上会验证文件的 MIME 类型，其通过读取文件的内容以猜测它的 MIME 类型。

可以在以下链接中找到完整的 MIME 类型列表及其相应的扩展名：
https://svn.apache.org/repos/asf/httpd/htt...

min:value

验证中的字段必须具有最小值。字符串、数字、数组或是文件大小的计算方式都用 size 方法进行评估。

not_in:foo,bar,...

验证的字段不能包含在给定的值列表中。Rule::notIn

lte:
field
🎜🎜Le champ en cours de validation doit être inférieur ou égal au étant donné 🎜Champ🎜. Les deux champs doivent être du même type. Les tailles de chaîne, numérique, tableau et fichier sont calculées et évaluées avec la méthode size. 🎜🎜🎜🎜
🎜🎜max:🎜value🎜🎜🎜Les champs en validation doivent être inférieurs ou égaux à 🎜value 🎜. Les calculs de chaîne, de nombre, de tableau ou de taille de fichier sont évalués à l'aide de la méthode size. 🎜🎜🎜🎜
🎜🎜mimetypes:🎜text/plain🎜,...🎜🎜Le fichier vérifié doit être le identique à donné Correspond à l'un des types MIME spécifiés : 🎜rrreee🎜 Pour déterminer le type MIME d'un fichier téléchargé, le contenu du fichier est lu pour déterminer le type MIME, qui peut être différent du type MIME fourni par le client. 🎜🎜🎜🎜
🎜🎜mimes:🎜foo🎜,🎜bar🎜,...🎜🎜Des documents vérifiés sont requis Possède un type MIME correspondant à l’une des extensions répertoriées. 🎜
🎜🎜Utilisation de base des règles MIME🎜rrreee🎜Même si vous n'avez peut-être besoin que de vérifier l'extension spécifiée, cette règle vérifie en fait le type MIME du fichier, qui est lu par Récupérer le contenu d'un fichier pour deviner son type MIME. 🎜🎜Une liste complète des types MIME et de leurs extensions correspondantes est disponible sur le lien suivant :
https://svn.apache.org/repos/asf/httpd/htt... 🎜🎜🎜🎜
🎜🎜min:🎜value🎜🎜🎜Les champs en validation doivent avoir une valeur minimale. Les calculs de chaîne, de nombre, de tableau ou de taille de fichier sont évalués à l'aide de la méthode size🎜. 🎜🎜🎜🎜
🎜🎜not_in:🎜foo🎜,🎜bar🎜,...🎜🎜champ vérifié ne peut pas être inclus dans la liste de valeurs donnée. La méthode Rule::notIn peut être utilisée pour construire des règles : 🎜rrreee🎜🎜🎜🎜🎜🎜

not_regex:pattern

Le champ en cours de validation ne doit pas correspondre à l'expression régulière donnée.

En interne, cette règle utilise la fonction PHP preg_match. La valeur saisie doit suivre le même format requis par la fonction preg_match, donc inclure également des délimiteurs valides. Par exemple : 'email' => 'not_regex:/^.+$/i'. preg_match 函数。输入的值应遵循 preg_match 函数所需的相同格式，因此也包括有效的分隔符。例如：'email' => 'not_regex:/^.+$/i'。

注意： 当使用 regex/not_regex 模式时，可能需要在数组中指定规则，而不是使用管道分隔符，尤其是在正则表达式包含管道字符的情况下。

nullable

验证的字段可以为 null。这在验证基本数据类型时特别有用，例如可以包含空值的字符串和整数。

numeric

验证的字段必须是数字。

present

验证的字段必须存在于输入数据中，但可以为空。

regex:pattern

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

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

注意： 当使用 regex 规则时，你必须使用数组，而不是使用 | 分隔符，特别是如果正则表达式包含 | 字符。

required

验证的字段必须存在于输入数据中，而不是空。如果满足以下条件之一，则字段被视为「空」：

  • 值为 null。
  • 值为空字符串。
  • 值为空数组或空 Countable 对象。
  • 值为无路径的上传文件。

required_if:anotherfield,value,...

如果 anotherfield 字段等于任一 value，验证的字段必须出现且不为空 。

如果你想为 required_if 规则构造一个更复杂的条件，你可以使用 Rule::requiredIf 方法。此方法接受布尔值或闭包。当传递一个闭包时，应返回 true 或 false

Remarque : Lors de l'utilisation du modèle regex/not_regex, il peut être nécessaire de spécifier les règles dans un tableau au lieu d'utiliser un délimiteur de canal. , en particulier dans le cas où l'expression régulière contient des caractères pipe.

nullable🎜🎜Le champ vérifié peut être null. Ceci est particulièrement utile lors de la validation de types de données de base, tels que des chaînes et des entiers, qui peuvent contenir des valeurs nulles. 🎜🎜🎜🎜
🎜🎜numeric🎜🎜Le champ à vérifier doit être numérique. 🎜🎜🎜🎜
🎜🎜present🎜🎜Le champ en cours de validation doit exister dans les données d'entrée, mais peut être vide. 🎜🎜🎜🎜
🎜🎜regex:🎜pattern🎜🎜🎜Les champs en cours de validation doivent correspondre à l'expression régulière donnée. 🎜🎜 En interne, cette règle utilise la fonction PHP preg_match. La valeur saisie doit suivre le même format requis par la fonction preg_match, incluant donc des délimiteurs valides. Par exemple : 'email' => 'regex:/^.+@.+$/i'. 🎜🎜Remarque : Lorsque vous utilisez la règle regex, vous devez utiliser un tableau au lieu d'utiliser le délimiteur |, surtout si l'expression régulière contient < code>| caractères. 🎜🎜🎜🎜
🎜🎜required🎜🎜Le champ à vérifier doit exister dans les données d'entrée et ne pas être vide. Un champ est considéré comme « nul » si l'une des conditions suivantes est remplie : 🎜
  • La valeur est null.
  • La valeur est une chaîne vide.
  • La valeur est un tableau vide ou un objet Countable vide.
  • La valeur est un fichier téléchargé sans chemin.
🎜🎜🎜🎜
🎜🎜required_if:🎜un autre champ🎜,🎜valeur🎜 ,...🎜🎜Si le champ 🎜anotherfield🎜 est égal à n'importe quelle 🎜value🎜, le champ validé doit être présent et non vide. 🎜🎜Si vous souhaitez construire une condition plus complexe pour la règle required_if, vous pouvez utiliser la méthode Rule::requiredIf. Cette méthode accepte une valeur booléenne ou une fermeture. Lors du passage d'une fermeture, true ou false doit être renvoyé pour confirmer si le champ doit être validé : 🎜rrreee🎜🎜🎜🎜🎜🎜

required_unless:anotherfield,value,...

Si le champ anotherfield n'est égal à aucune value, le champ validé doit être présent et non vide.

required_with:foo,bar,...

Le champ validé doit apparaître et ne pas être vide uniquement lorsqu'un autre champ spécifié apparaît.

required_with_all:foo,bar,...

Le champ vérifié doit apparaître et ne pas être vide uniquement lorsque tous les autres champs spécifiés apparaissent.

required_without:foo,bar,...

Seulement lorsqu'un autre champ spécifié n'apparaît pas, le champ vérifié doit apparaître et ne pas être vide.

required_without_all:foo,bar,...

Le champ vérifié doit apparaître et ne pas être vide uniquement lorsque tous les autres champs spécifiés n'apparaissent pas.

idem:champ

Le champ en cours de validation doit correspondre au champ donné.

size:value

Le champ en cours de validation doit avoir une taille qui correspond à la valeur donnée. Pour les chaînes, la valeur correspond au nombre de caractères. Pour les nombres, la valeur correspond à la valeur entière donnée. Pour les tableaux, la taille correspond à la valeur count du tableau. Pour les fichiers, la taille correspond à la taille du fichier en Ko. count 值。对于文件，size 对应文件大小（单位 kb）。

starts_with:foo,bar,...

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

string

验证的字段必须是一个字符串。如果允许这个字段为 null，需要给这个字段分配 nullable 规则。

timezone

验证的字段必须是一个基于 PHP 函数  timezone_identifiers_list

starts_with:
foo
,🎜bar🎜,...🎜🎜champ vérifié doit commencer par l’une des valeurs données. 🎜🎜🎜🎜
🎜🎜string🎜🎜Le champ à vérifier doit être une chaîne. Si ce champ peut être null, la règle nullable doit être attribuée à ce champ. 🎜🎜🎜🎜
🎜🎜timezone🎜🎜Le champ à vérifier doit être une fonction basée sur PHP timezone_identifiers_list Identifiant de fuseau horaire valide. 🎜🎜🎜🎜🎜🎜🎜

unique : table, column, sauf, idColumn

Les champs à valider doivent être uniques au sein de la table de base de données donnée. Si colonne n'est pas spécifié, le nom du champ lui-même sera utilisé. column ，将会使用字段本身的名称。

指定自定义字段

rrreee

自定义数据库连接

有时，你可能需要为验证程序创建的数据库查询设置自定义连接。上面的例子中，将 unique:users 设置为验证规则，等于使用默认数据库连接来查询数据库。如果要对其进行修改，请使用「点」方法指定连接和表名：

rrreee

强迫 Unique 规则忽略指定 ID ：

有时，你可能希望在进行字段唯一性验证时忽略指定 ID 。例如， 在「更新个人资料」页面会包含用户名、邮箱和地点。这时你会想要验证更新的 E-mail 值是否唯一。如果用户仅更改了用户名字段而没有改 E-mail 字段，就不需要抛出验证错误，因为此用户已经是这个 E-mail 的拥有者了。

使用 Rule 类定义规则来指示验证器忽略用户的 ID。这个例子中通过数组来指定验证规则，而不是使用 | 字符来分隔：

rrreee

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

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

rrreee

如果你的数据表使用的主键名称不是 id ，那就在调用 ignore 方法时指定字段的名称：

rrreee

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

rrreee

增加额外的 Where 语句：

你也可以通过 where 方法指定额外的查询条件。例如， 我们添加 account_id 为 1

Spécifiez les champs personnalisés

rrreeeConnexion à la base de données personnalisée

Parfois, vous devrez peut-être configurer une connexion personnalisée pour la requête de base de données créée par le validateur. Dans l'exemple ci-dessus, définir unique:users comme règle de validation équivaut à utiliser la connexion à la base de données par défaut pour interroger la base de données. Si vous souhaitez le modifier, veuillez utiliser la méthode "point" pour spécifier la connexion et le nom de la table :
rrreee
Forcer la règle Unique pour ignorer l'ID spécifié :

Parfois, vous souhaiterez peut-être vérifier l'unicité d'un champ en ignorant l'ID spécifié. Par exemple, la page « Mettre à jour le profil » comprendra votre nom d'utilisateur, votre adresse e-mail et votre emplacement. À ce stade, vous souhaiterez vérifier que la valeur de l'e-mail mise à jour est unique. Si l'utilisateur modifie uniquement le champ du nom d'utilisateur mais pas le champ de l'e-mail, il n'est pas nécessaire de générer une erreur de validation car l'utilisateur est déjà propriétaire de l'e-mail.

Utilisez la classe Rule pour définir des règles permettant au validateur d'ignorer l'ID de l'utilisateur. Cet exemple spécifie les règles de validation sous forme de tableau, plutôt que d'utiliser des caractères | pour les séparer :

rrreee

{tip} Vous ne devez jamais transmettre aucune entrée de requête contrôlée par l'utilisateur à la méthode ignore. Au lieu de cela, vous devez transmettre uniquement les ID uniques générés par le système, tels que les ID à incrémentation automatique ou les UUID, à partir des instances du modèle Eloquent. Sinon, votre application sera vulnérable aux attaques par injection SQL.

Au lieu de transmettre la valeur de la clé du modèle à la méthode ignore, vous pouvez transmettre l'intégralité de l'instance du modèle. Laravel extraira automatiquement la clé primaire du modèle :
rrreee
Si votre table de données utilise un nom de clé primaire autre que id, alors spécifiez le nom du champ lors de l'appel de ignore :

rrreee

Par défaut, la règle unique vérifiera si la colonne correspondant au nom de l'attribut en cours de validation est unique. Mais vous pouvez transmettre différents noms de colonnes comme deuxième argument à la méthode unique :

rrreee

Ajouter des instructions Where supplémentaires :

Vous pouvez également transmettre where spécifie des conditions de requête supplémentaires. Par exemple, nous ajoutons account_id comme contrainte de 1 : rrreee

url🎜🎜Le champ validé doit être une URL valide. 🎜🎜🎜🎜🎜🎜🎜🎜uuid🎜🎜Le champ de validation doit être un identifiant universellement unique (UUID) RFC 4122 (version 1,3,4 ou 5) valide. 🎜🎜🎜🎜🎜🎜🎜🎜Ajouter des règles selon conditions🎜🎜🎜

Valider si présent

Dans certains cas, les contrôles de validation ne peuvent être effectués sur un champ que si ce champ existe dans le tableau. Ceci peut être réalisé en ajoutant parfois à la liste des règles : sometimes 到规则列表来实现：

rrreee

在上面的例子中， email 字段只有在 $data 数组中存在才会被验证。

{tip} 如果你尝试验证应该始终存在但可能为空的字段，请查阅 可选字段的注意事项

复杂的条件验证

有时候你可能需要增加基于更复杂的条件逻辑的验证规则。例如，你可以希望某个指定字段在另一个字段的值超过 100 时才为必填。或者当某个指定字段存在时，另外两个字段才能具有给定的值。增加这样的验证条件并不难。首先，使用 静态规则 创建一个 Validator 实例：

rrreee

假设我们有一个专为游戏收藏家所设计的网页应用程序。如果游戏收藏家收藏超过一百款游戏，我们会希望他们来说明下为什么他们会拥有这么多游戏。比如说他们有可能经营了一家游戏分销商店，或者只是为了享受收集的乐趣。为了在特定条件下加入此验证需求，可以在 Validator 实例中使用 sometimes 方法。

rrreee

传入 sometimes 方法的第一个参数是要用来验证的字段名称。第二个参数是我们想使用的验证规则。 闭包 作为第三个参数传入，如果其返回 true ， 则额外的规则就会被加入。这个方法可以轻松地创建复杂的条件验证。你甚至可以一次对多个字段增加条件验证：

rrreee

{tip} 传入 闭包 的 $input 参数是 IlluminateSupportFluent 的一个实例，可用来访问你的输入或文件对象。

验证数组

验证表单的输入为数组的字段也不难。你可以使用 「点」方法来验证数组中的属性。例如，如果传入的 HTTP 请求中包含 photos[profile] 字段， 可以如下验证：

rrreee

你也可以验证数组中的每个元素。例如，要验证指定数组输入字段中的每一个 email 是唯一的，可以这么做：

rrreee

同理，你可以在语言文件定义验证信息时使用 *rrreee

Dans l'exemple ci-dessus, le champ email n'existe que dans le $data le tableau sera vérifié.

{tip} Si vous essayez de valider un champ qui devrait toujours être présent mais qui peut être vide, consultez les Remarques sur les champs facultatifs

< /blockquote>
Validation conditionnelle complexe

Parfois, vous devrez peut-être ajouter des règles de validation basées sur une logique conditionnelle plus complexe. Par exemple, vous souhaiterez peut-être qu'un champ spécifié soit obligatoire uniquement si la valeur d'un autre champ dépasse 100. Ou lorsqu'un champ spécifié existe, les deux autres champs peuvent avoir la valeur donnée. L'ajout de telles conditions de vérification n'est pas difficile. Tout d'abord, créez une instance Validator en utilisant une règle statique :

rrreee Disons que nous avons une application Web conçue pour les collectionneurs de jeux. Si un collectionneur de jeux possède plus d’une centaine de jeux dans sa collection, nous aimerions qu’il explique pourquoi il possède autant de jeux. Par exemple, ils peuvent gérer un magasin de distribution de jeux ou simplement aimer collectionner. Pour ajouter cette exigence de validation sous certaines conditions, vous pouvez utiliser la méthode parfois sur une instance Validator. rrreee

Le premier paramètre passé dans la méthode parfois est le nom du champ à utiliser pour la validation. Le deuxième paramètre est la règle de validation que nous souhaitons utiliser. Closure est transmis comme troisième paramètre. S'il renvoie true, des règles supplémentaires seront ajoutées. Cette méthode facilite la création de validations conditionnelles complexes. Vous pouvez même ajouter une validation conditionnelle à plusieurs champs à la fois :
rrreee
{tip} Le paramètre $input passé dans la closure est IlluminateSupportFluent qui peut être utilisée pour accéder à vos objets d'entrée ou de fichier. 🎜
🎜🎜🎜
🎜🎜Validation des tableaux🎜🎜Il n'est pas difficile de valider les champs où la saisie de le formulaire est un tableau. Vous pouvez utiliser la méthode "dot" pour valider les propriétés d'un tableau. Par exemple, si la requête HTTP entrante contient le champ photos[profile], elle peut être vérifiée comme suit : 🎜rrreee🎜 Vous pouvez également vérifier chaque élément du tableau. Par exemple, pour vérifier que chaque e-mail dans le champ de saisie du tableau spécifié est unique, vous pouvez faire ceci : 🎜rrreee🎜De même, vous pouvez utiliser les caractères * lors de la définition des informations de vérification dans le fichier de langue, qui est basé sur le tableau Utiliser un seul message de validation pour les champs : 🎜rrreee🎜🎜🎜🎜🎜🎜🎜Règles de validation personnalisées🎜🎜🎜🎜🎜🎜🎜

Utilisation d'objets de règle

Laravel fournit de nombreuses règles de validation utiles et prend également en charge les règles personnalisées. Une façon d’enregistrer des règles de validation personnalisées consiste à utiliser un objet règle. Vous pouvez utiliser la commande Artisan make:rule pour générer de nouveaux objets de règle. Utilisons ensuite cette commande pour générer une règle qui valide qu'une chaîne est en majuscule. Laravel stockera les nouvelles règles dans le répertoire app/Rules : make:rule 来生成新的规则对象。接下来，让我们用这个命令生成一个验证字符串是大写的规则。Laravel 会将新的规则存放在 app/Rules 目录中：

rrreee

一旦创建了规则，我们就可以定义它的行为。规则对象包含两个方法： passes 和 message。passes 方法接收属性值和名称，并根据属性值是否符合规则而返回  true 或 false。 message 方法应返回验证失败时应使用的验证错误消息：

rrreee

当然， 如果你希望从翻译文件中返回一个错误消息，你可以从 message 方法中调用辅助函数 trans：

rrreee

一旦规则对象被定义好后，你可以通过将规则对象的实例和其他验证规则一起来传递给验证器：

rrreee

使用闭包

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

rrreee

使用扩展

注册自定义的验证规则的另一种方法是使用 Validator facade 中的 extend 方法。让我们在 服务容器 中使用这个方法来注册自定义验证规则：

rrreee

自定义的验证闭包接收四个参数：要被验证的属性名称 $attribute、属性的值 $value、传入验证规则的参数数组 $parameters 、以及 Validator 实列。

除了使用闭包，你也可以传入类和方法到 extend 方法中：

rrreee

定义错误消息

你还需要为自定义规则定义错误信息。你可以使用内联自定义消息数组或者在验证语言文件中添加条目来实现这一功能。 消息应该被放到数组的第一位， 而不是在只用于存放属性指定错误信息的 custom 数组内：

rrreee

当创建一个自定义验证规则时，你可能有时候需要为错误信息定义自定义占位符。可以通过创建自定义验证器然后调用 Validator 门面上的  replacer 方法。你可以在 服务容器 的 bootrrreee

Une fois la règle créée, nous pouvons définir son comportement. L'objet règle contient deux méthodes : passes et message. La méthode passes reçoit une valeur et un nom d'attribut, et renvoie true ou false selon que la valeur d'attribut est conforme aux règles. La méthode message doit renvoyer le message d'erreur de validation qui doit être utilisé si la validation échoue :
rrreee
Bien sûr, si vous souhaitez renvoyer un message d'erreur depuis le fichier de traduction, vous pouvez le faire depuis le < méthode code>message Appelez la fonction d'assistance trans dans trans : 🎜rrreee🎜Une fois l'objet règle défini, vous pouvez passer une instance de l'objet règle à le validateur ainsi que d'autres règles de validation : 🎜rrreee🎜🎜
🎜🎜Utilisez des fermetures🎜🎜Si vous seulement Si vous avez besoin de la fonctionnalité de règles personnalisées une fois dans votre application, vous pouvez utiliser des fermetures au lieu d'objets de règle. La fermeture reçoit le nom de l'attribut. Si la valeur de l'attribut échoue à la validation, $fail doit être utilisé dans le rappel : 🎜rrreee🎜🎜
🎜🎜Utiliser des extensions🎜🎜Une autre façon d'enregistrer des règles de validation personnalisées consiste à utiliser extend dans le Validator méthode de façade. Utilisons cette méthode pour enregistrer des règles de validation personnalisées dans le conteneur de service : 🎜rrreee🎜La fermeture de validation personnalisée reçoit quatre paramètres : le nom de l'attribut à valider $attribute, la valeur de l'attribut < code>$value, le tableau de paramètres $parameters passé dans la règle de validation et la colonne réelle Validator. 🎜🎜En plus d'utiliser des fermetures, vous pouvez également transmettre des classes et des méthodes à la méthode extend : 🎜rrreee
🎜

Définition Message d'erreur

🎜Vous devez également définir des messages d'erreur pour les règles personnalisées. Vous pouvez obtenir cette fonctionnalité en utilisant un tableau de messages personnalisé en ligne ou en ajoutant une entrée dans le fichier de langage de validation. Le message doit être placé en premier dans le tableau, pas dans le tableau custom qui est uniquement utilisé pour stocker les messages d'erreur spécifiques aux attributs : 🎜rrreee🎜Lors de la création d'une règle de validation personnalisée, vous pouvez parfois avoir besoin d'espaces réservés personnalisés à définir pour les messages d'erreur. Cela peut être fait en créant un validateur personnalisé, puis en appelant la méthode Replacer sur la façade Validator. Vous pouvez effectuer les opérations suivantes dans la méthode boot du conteneur de service : 🎜rrreee🎜🎜

Expansion implicite

Par défaut, lorsque l'attribut à valider n'existe pas ou contient une valeur nulle définie par la règle requiredrequired 规则定义的空值时，那么正常的验证规则，包括自定义扩展将不会执行。 例如，unique 规则将不会检验 null 值：

rrreee

如果要求即使为空时也要验证属性，则必须要暗示属性是必须的。要创建这样一个「隐式」扩展， 可以使用 Validator::extendImplicit(), alors les règles de validation normales, y compris les extensions personnalisées, ne seront pas mises en œuvre. Par exemple, la règle unique

ne validera pas la valeur null :
rrreee

si nécessaire pour valider la propriété même si c'est null , cela doit impliquer que l'attribut est requis. Pour créer une telle extension "implicite", utilisez la méthode Validator::extendImplicit() :

rrreee
Cet article a été publié pour la première fois sur le site
LearnKu.com🎜. 🎜🎜
←
→

Site Web PHP chinois

MaisonMaisonCoursCoursArticleArticleQuestions et réponsesQuestions et réponsesDictionnaireDictionnaireManuelManuelTéléchargerTéléchargerrechercherechercheAPPTélécharger APPTélécharger