A validação é uma parte importante de qualquer aplicação web, pois ajuda a garantir que os dados enviados pelos usuários sejam válidos e seguros. No Laravel, validation é fácil de implementar e pode ser aplicada a várias áreas, incluindo formulários, solicitações API e muito mais.
Neste guia, você aprenderá como implementar a validação no Laravel, incluindo exemplos práticos de como validar diferentes tipos de dados.
Laravel Validation é uma forma de garantir que os dados enviados para o servidor sejam válidos e atendam requisitos definidos. Laravel fornece uma série de regras de validação predefinidas, bem como a capacidade de criar regras personalizadas para atender às necessidades específicas da sua aplicação.
A validação no Laravel pode ser implementada de várias maneiras, incluindo:
Independentemente da área em que a validação é necessária, o Laravel usa um processo de três etapas para validar dados:
Laravel fornece várias funções que ajudam de validação e que podem ser utilizadas para validar os dados de uma request.
Ok, para os próximos exemplos, você vai precisar de um controller. Se caso o seu controller ainda não tiver criado um ainda, você pode criar um facilmente utilizando o comando abaixo:
php artisan make:controller PostController --api
O que deve gerar algo parecido com isso:
class PostController extends Controller
{
/**
* Display a listing of the resource.
*
* @return JsonResponse
* @throws AuthorizationException
*/
public function index()
{
//
}
/**
* Store a newly created resource in storage.
*
* @param Request $request
* @return Response
*/
public function store(Request $request)
{
//
}
/**
* Display the specified resource.
*
* @param int $id
* @return Response
*/
public function show($id)
{
//
}
/**
* Update the specified resource in storage.
*
* @param Request $request
* @param int $id
* @return Response
*/
public function update(Request $request, $id)
{
//
}
/**
* Remove the specified resource from storage.
*
* @param int $id
* @return Response
*/
public function destroy($id)
{
//
}
}
Ok, próximo passo, rotas. Você precisa garantir que sua aplicação tenha rotas que vão direcionar para esse controller. Faremos assim, abra o arquivo routes/api.php do seu projeto Laravel e adicione uma nova linha:
Route::apiResource('posts', PostController::class);
Isso é tudo o que você precisa para acessar os métodos do nosso controller. Laravel automaticamente mapeia as rotas com métodos equivalentes:
| Verbo | URI | Ação | Nome da rota |
|---|---|---|---|
| GET | /posts | index | posts.index |
| POST | /posts | store | posts.store |
| GET | /posts/{post} | show | posts.show |
| PUT/PATCH | /posts/{post} | update | posts.update |
| DELETE | /posts/{post} | destroy | posts.destroy |
Agora que seu controller foi criado e suas rotas já foram criadas, vamos focar no método store do nosso PostController, que será responsável por armazenar um novo Post.
A primeira alternativa que nós temos para validar as entradas do usuário é utilizando o método validate()diretamente na variável $request do seu controller. Aqui está um exemplo de como utilizar a função para validar e armazenar um novo post.
/**
* Store a new blog post.
*/
public function store(Request $request)
{
$validated = $request->validate([
'title' => 'required|unique:posts|max:255',
'body' => 'required',
]);
// Os dados da request são válidos...
// Cria um novo post...
Post::create($validated);
return Response::json([
'errors' => false,
'message' => 'Post created',
], 200);
}
Assim que uma requisição POST é feita para o endpoint /posts o método store é executado, isso inicia o processo de validação dos dados.
Como você pode ver, as regras da validação são passadas para o método validate(). Todas as regras de validação disponíveis você pode encontrar aqui.
Nossa validação aqui consiste de duas regras, uma para o titulo e outra para o body. Os dois são marcados com required, mas o title deve ser único, e dever ter no máximo 255 caracteres. Você pode ser bem mais efetivo com a sua validação, e nunca confie 100% nos dados vindos do usuário.
A melhor parte é, que se a validação falhar, a resposta com o erro será automaticamente gerada. Se a validação passar, o método continuará a executar normalmente.
Para cenários onde a validação é mais complexa e/ou tem muitos campos, Laravel fornece uma funcionalidade nativa chamada Form Request Validation, que lhe permite criar uma classe separada para as regras de validação. Para criar FormRequest você pode usar o comando:
php artisan make:request StorePostRequest
A classe é utilizada para validar os dados de uma request antes de ser passada para o método do controller. Um exemplo de como utilizar o Form Request para o mesmo post do exemplo anterior:
class StorePostRequest extends FormRequest
{
public function authorize()
{
return true;
}
public function rules()
{
return [
'title' => 'required|unique:posts|max:255',
'body' => 'required|min:10',
'cover' => 'dimensions:min_width=100,min_height=200',
'author' => 'required|unique:authors',
];
}
}
A classe tem dois métodos, o método authorize é responsável por determinar se o usuário logado pode ou não executar a ação, enquanto o método de rules devolve as regras para a validação que devem ser aplicadas aos dados na request.
Então, como acessar os dados depois da validação? Tudo o que precisa de fazer é inserir o FormRequest nesse caso a nossa classe StorePostRequest como parâmetro da sua função store no controller. A request é validada antes do método no seu controller ser executado, o que significa que você não precisa acrescentar nenhuma lógica de validação no seu controller.
/**
* Store a new blog post.
*/
public function store(StorePostRequest $request)
{
// A request é valida
// Acessa todos os dados validados...
$validated = $request->validated();
// Acessa apenas uma parte dos dados validados...
$validated = $request->safe()->only(['name', 'email']);
$validated = $request->safe()->except(['name', 'email']);
// Cria um novo post...
Post::create($validated);
return Response::json([
'errors' => false,
'message' => 'Post created',
], 200);
}
Se você não quiser utilizar o método validate na sua request você pode criar um validator manualmente utilizando o Validator Facade.
class PostController extends Controller
{
/**
* Store a new blog post.
*
* @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 Response::json([
'errors' => true,
'message' => 'Dados incompletos ou errados, por favor verifique',
], 422);
}
// A request é valida
// Acessa todos os dados validados...
$validated = $validator->validated();
// Acessa apenas uma parte dos dados validados...
$validated = $validator->safe()->only(['name', 'email']);
$validated = $validator->safe()->except(['name', 'email']);
// Store the blog post...
return Response::json([
'errors' => false,
'message' => 'Post created',
], 200);
}
}
O primeiro argumento passado para o método make() são os dados para a validação. O segundo argumento é um conjunto de regras de validação que devem ser aplicadas aos dados.
Após determinar se a validação falhou ou não, você pode decidir qual mensagem retornar para o usuário, ao invés da mensagem auto gerada pelo framework, isso de da um pouco mais de flexibilidade trabalhando com a validação dos dados.
A validação é uma parte importante de qualquer aplicação web, pois ajuda a garantir que os dados enviados pelos usuários sejam válidos e seguros. O Laravel torna a implementação da validação fácil e intuitiva, permitindo que você defina suas próprias regras de validação personalizadas e oferecendo uma série de regras predefinidas para atender a diferentes necessidades.
Neste guia, aprendemos como implementar a validação no Laravel e vimos alguns exemplos práticos de como validar diferentes tipos de dados. Esperamos que isso ajude você a tornar suas aplicações Laravel mais seguras e eficientes!
Deixe um comentário