web-dev-qa-db-fra.com

Laravel 5.6 $ this-> validate vs Validator :: make ()

J'ai vu qu'il y avait quelques autres questions dans lesquelles ils demandaient quelle était la différence entre $this->validate Et Validator::make(). Ils n'ont pas vraiment répondu à la question conceptuelle que je me posais.

Y a-t-il une utilisation appropriée pour chacun d'eux? Comme quand utiliser l'un contre l'autre?

Comment je l'utilise actuellement dans mes classes d'API J'utilise un if else avec $validator::make() (comme ci-dessous) tandis que dans ma partie Web du programme j'utilise $ this->validate() (également ci-dessous)

Est-ce une bonne façon de l'utiliser?

$ validator :: make:

public function store(Request $request)
    {
        $validator = Validator::make($request->all(),[
            'name' => 'required',
            'url' => 'required',
            'isPublic' => 'required'
        ]);

        if($validator->fails()){
            return response($validator->messages(), 200);
        } else {

            Helpers::storeServer($request);

            return response()->json([
                'message'=> ['Server Stored']
            ]);
        }
    }

$ this-> valider:

 public function store(Request $request)
    {

        $this->validate($request, [
            'name' => 'required',
            'url' => 'required',
            'isPublic' => 'required'
        ]);

        Helpers::storeServer($request);

        return redirect('dashboard')->with('success', 'Server stored');
    }
phplaravelvalidation
7
Striker

Non, ils font exactement la même chose de deux manières différentes. Je veux dire que littéralement, $this->validate() appelle la méthode make() sur la classe de validation. Si vous regardez ValidatesRequests.php, implémenté par controller.php que votre contrôleur étend. La méthode validate() appelle:

$validator = $this->getValidationFactory()
             ->make($request->all(), $rules, $messages, $customAttributes);

Il finit donc par utiliser la méthode make() finalement. Il y a une différence dans la façon dont il est géré, car $this->validate Appelle:

if ($validator->fails()) {
    this->throwValidationException($request, $validator);
}

Ainsi, l'utilisation de Validator::make() vous permettra de gérer l'exception vous-même, au lieu que $this->validate() lance automatiquement l'exception de validation pour vous. C'est utile pour faire quelque chose avant votre redirection. Vous le montrez dans votre premier exemple, car vous vérifiez si la validation échoue avant de décider comment la gérer. Dans le deuxième exemple, vous savez que si la validation échoue, elle refusera automatiquement la demande.

10
N Mahurin

en cas d'échec des règles sur $this->validate, lancera automatiquement une erreur

$validator::make: vous pouvez facilement gérer les erreurs et vous pouvez envelopper toutes les données dans array () et les passer à $validator::make: pour validation

et aussi si vous souhaitez utiliser FormRequest + Route Model Binding

votre magasin () ressemble à ceci

public function store(YourFormRequestRules $request)
    {
        Helpers::storeServer($request);

        return redirect('dashboard')->with('success', 'Server stored');
    }

public function update(YourFormRequestRules $request, Post $post)
{
    $post->title = $request->input('title');
    $post->save();
    return redirect()->route('example.index');
}

c'est tout

1
kenken9999

L'utilisation de $this->validate(): YourController étend une classe Controller qui utilise le trait ValidatesRequests et ressemble à ceci:

namespace App\Http\Controllers;

use Illuminate\Foundation\Bus\DispatchesJobs;
use Illuminate\Routing\Controller as BaseController;
use Illuminate\Foundation\Validation\ValidatesRequests;
use Illuminate\Foundation\Auth\Access\AuthorizesRequests;

class Controller extends BaseController
{
    use AuthorizesRequests, DispatchesJobs, ValidatesRequests;
}

Le trait ValidatesRequests lui-même est composé de plusieurs méthodes que le contrôleur de base obtient puis de votre propre contrôleur et qui comprend:

validateWith($validator, Request $request = null)
...
validate(Request $request, array $rules, array $messages = [], array $customAttributes = [])
...
validateWithBag($errorBag, Request $request, array $rules, array $messages = [], array $customAttributes = [])
... and so on...

Ces méthodes aident à rendre la gestion des erreurs de validation et de requête très pratique et, en fait, compte tenu de la méthode validate() mentionnée.

Lorsqu'il y a une erreur de validation dans la demande passée, cela vous aide à gérer la réponse sans mettre votre contrôleur avec une logique inutile; c'est-à-dire que lorsqu'il s'agit d'un appel ajax, il renvoie une réponse 422 avec un corps json tandis qu'il retourne remplit le sac d'erreur et remplit la variable $errors à utiliser dans le modèle de lame pour non-ajax.

En résumé, cela vous aide uniquement au cas où vous ne voudriez pas faire de validation manuelle en créant une instance de Validator, afin de garder le développeur concentré sur le travail réel;)

MISE À JOUR: 

$validator = Validator::make() //creates an instance of the validator for further operations

// You can even do after the creating the instance of validator:
$this->validateWith($validator, $request)

//Lets do both steps above i.e the validation and trigger the Validation Exception if there's failure.
$this->validate($request, [...rules...], [...messages..])

Vérifier: https://laravel.com/docs/5.6/validation#quick-writing-the-validation-logic

1
Oluwatobi Samuel Omisakin