Tutorial Laravel: tudo o que você precisa saber para começar com o framework

O Laravel é um framework PHP de código aberto muito conhecido por sua sintaxe amigável e sua comunidade ativa. Ele é bastante popular entre desenvolvedores PHP para a construção de vários tipos de aplicações web, como lojas virtuais, plataformas de mídia social e sistemas de gerenciamento de conteúdo.

Se você não sabe bem por onde começar, este tutorial Laravel vai explicar tudo sobre este framework, incluindo seus benefícios, processo de instalação e termos importantes. Você também aprenderá conceitos mais avançados, como o comando PHP Artisan e como lidar com erros. Vamos lá?

Começando com Laravel

Frameworks como o Laravel fornecem ferramentas e recursos pré-construídos que permitem aos desenvolvedores criar um aplicativo sem escrever todo o código do zero. Por exemplo, você pode instalar o pacote Bagisto para adicionar funcionalidades de e-commerce, como gerenciamento de estoque.

O Laravel é muito popular especialmente por conta das seguintes características. Nós vamos abordá-los com mais detalhes nas próximas seções:

• Sintaxe elegante – o Laravel permite que você use um código PHP mais simples, eficiente e legível para agilizar o processo de desenvolvimento.
• Arquitetura MVC – O modelo Model-view-controller do Laravel fornece uma estrutura mais clara para os componentes do seu aplicativo.
• PHP Artisan – Uma ferramenta de linha de comando que simplifica tarefas complexas durante o desenvolvimento, como atualizações de banco de dados ou criação de componentes.
• Eloquent ORM – O mapeamento objeto-relacional Eloquent fornece uma comunicação de banco de dados mais direta através da abordagem orientada a objetos.

Em termos de sistema operacional, você pode instalar o Laravel no Ubuntu, no CentOS e em outras distribuições Linux populares. Antes de fazer isso, no entanto, você deve configurar alguns componentes de software, incluindo o runtime do PHP, Composer e Apache. Se você quiser um processo de instalação muito simples, basta adquirir um plano de Hospedagem VPS Laravel da Hostinger. Com ele, você pode completar o processo de configuração inicial e ter o Laravel instalado automaticamente em cerca de 15 minutos.

Além disso, você deve configurar um ambiente de desenvolvimento integrado (IDE) no seu computador para escrever o código da sua aplicação. Para implantar um aplicativo Laravel no seu VPS, você precisa de Git ou de um software de automação, como o Jenkins.

Entendendo a arquitetura MVC

Um dos conceitos mais importantes no Laravel é a sua arquitetura MVC. Basicamente falando, esse modelo permite que os desenvolvedores dividam um aplicativo em três componentes para facilitar o gerenciamento de código, a priorização a separação de conceitos.

Componentes de modelo

Os componentes de modelo representam a lógica de negócio e armazenamento do seu aplicativo. Eles são responsáveis pelas operações de banco de dados, incluindo escrever e buscar informações específicas do back-end com base no pedido do usuário.

O Laravel usa o Eloquent ORM para lidar com operações relacionadas ao modelo, que usam a abordagem orientada a objetos. Isso torna a manipulação de dados muito mais rápida e flexível do que usar SQL.

Componentes de visualização

A camada de visualização define a área do seu aplicativo que os usuários podem ver na tela dos seus dispositivos e interagir. Ela cobre elementos como menus suspensos, caixas de texto e campos de formulário.

Para simplificar o desenvolvimento de componentes de visualização, o Laravel oferece um motor Blade que permite incorporar PHP em templates HTML. Esse recurso permite que você crie código reutilizável e exiba dados do back-end de maneira mais fácil.

Componentes do controlador

O controlador conecta os dois componentes anteriores na sua aplicação Laravel. Ele busca a solicitação de dados da camada de modelo e apresenta as informações processadas na interface para o componente de visualização.

Você pode usar vários métodos para dizer ao controlador para interagir com os dados de maneira diferente. Por exemplo, index recupera registros do banco de dados enquanto store insere novos recursos.

Criando rotas e URLs

Quando um usuário acessa sua aplicação, ele envia uma solicitação que será tratada por um controlador. A rota direciona a solicitação de entrada através de uma URL específica para alcançar o controlador apropriado e retornar dados para a camada de visualização.

Você pode criar múltiplas rotas Laravel com base nos métodos HTTP da solicitação — como GET, POST, PUT, DELETE e PATCH. Por padrão, eles estão localizados no arquivo web.php dentro da pasta routes do diretório do seu projeto Laravel.

Para criar uma rota, chame a função auxiliar Route ou a facade adicionando a seguinte linha no topo do seu arquivo web.php:

use Illuminate\Support\Facades\Route;

Em seguida, especifique sua rota. Por exemplo, a rota abaixo lidará com usuários que enviam a solicitação HTTP GETpara a URL dominio.tld/boas-vindas:

Route::get('/boas-vindas', function () {
  //Escreva sua lógica de controlador aqui;
});

Se você quer configurar uma rota para um controlador específico, também pode chamar sua facade e adicionar a rota como a seguir:

use App\Http\Controllers\HomeController;

Route::get('/home', [HomeController::class, 'index']);

No exemplo, nós direcionamos solicitações com o método GET de dominio.tld/home para o controlador HomeController, que vai lidar com isso usando o método  INDEX . A sintaxe  ::class permite que você use o controlador sem especificar todo o caminho da facade.

O Laravel pode processar solicitações através de um middleware antes de passá-las para os controladores para processamento adicional, como registro ou autenticação. Considere este exemplo:

Route::get('/boas-vindas', function () {
   return view('boas-vindas');
})->middleware('log.request');

Lembre-se, você deve criar o middleware através do PHP Artisan. Vamos explicar como fazer isso mais abaixo, na seção sobre técnicas avançadas do Laravel.

Trabalhando com controladores

Os controladores agrupam solicitações com a mesma lógica em uma classe. Isso torna o processamento mais eficiente, pois você pode fazer múltiplas solicitações usando um único manipulador.

Por exemplo, você pode criar um HomeController para processar todas as solicitações vindas da URL /home. Por padrão, os controladores estão localizados em app/Http/Controllers. Para configurar um controlador, execute o seguinte comando PHP artisan:

php artisan make:controller NomeDoControlador

Em seguida, defina os métodos de manipulação de solicitações dentro do novo arquivo. Por exemplo, o seguinte manipulador GET atende solicitações enviadas através da rota product/id:

namespace App\Http\Controllers;
use App\Models\Product;
use Illuminate\Http\Request;
class ProductController extends Controller
{
   // GET /product/{id}
   public function show($id)
   {
       $product = Product::find($id);
      
       if (!$product) {
           abort(404); // Retorna um erro 404 se o produto não for encontrado
       }
       return view('products.show', compact('product')); // Retorna uma visualização com os dados do produto
   }
}

Para lidar com as operações comuns de criar, ler, atualizar e deletar (CRUD), você pode configurar um controlador de recurso com um conjunto de métodos predefinidos. Aqui está o comando:

php artisan make:controller NomeDoControlador --controller

Criando visualizações com o motor de template Blade

O motor de template Blade proporciona uma integração perfeita do PHP no HTML usando uma sintaxe mais simples. Ele ajuda você a criar componentes de visualização para o seu aplicativo com mais facilidade.

Para construir uma visualização usando Blade, crie um arquivo com a extensão .blade.php dentro do diretório resources/views do seu projeto Laravel.

A estrutura do código é a mesma do HTML, mas com sintaxes adicionais para PHP. Por exemplo, você pode inserir uma variável assim:

<h1>{{ $title }}</h1>

No exemplo acima, o Laravel passa o valor da variável PHP $title para o componente de visualização, exibindo-o para os usuários.

Você também pode adicionar diretivas que manipulam seus elementos HTML usando funções PHP. Por exemplo, @ifpermite que você exiba um conteúdo específico se uma condição for atendida, como no seguinte:

@if($user->'Nome-de-usuário')
 <h1>Feliz em te ver, Nome-de-usuário!</h1>
@endif

Para melhorar a reutilização de código, o Blade oferece um recurso de herança de template que permite criar um layout mestre e adicionar componentes menores, chamados child views, separadamente. Você pode fazer isso usando as diretivas @extends, @section e @yield.

Por exemplo, temos um template mestre com o seguinte código:

<title>@yield('titulodosite')</title>

A diretiva @yield  é um espaço reservado para conteúdo de uma child view marcada com @section. Por exemplo, a linha abaixo irá inserir Seu Incrível Site na tag de título:

@section('titulodosite', 'Seu Incrível Site')

Por fim, adicione a diretiva @extends à child view para informar ao template principal qual arquivo ele deve usar para estender seu conteúdo.

Gerenciando o banco de dados com Eloquent ORM

Eloquent ORM permite que sua aplicação interaja com as tabelas do banco de dados de maneira mais eficiente usando um código mais curto do que o SQL tradicional. Em vez de manipular dados diretamente usando tabelas, o Laravel atribui um modelo para simplificar as operações de CRUD.

Você pode criar um novo modelo Eloquent em qualquer lugar dentro da pasta app do seu projeto Laravel, já que o arquivo Composer.json vai localizá-lo automaticamente. Se você não especificar um diretório, o framework de aplicação web usará o diretório padrão app/Models. Para criar um novo modelo, execute o comando PHP Artisan assim. Substitua Nome pelo nome do modelo que você deseja:

php artisan make:model Nome

Por padrão, o Laravel assume que a tabela correspondente é a forma em plural do nome do seu modelo. Por exemplo, o comando anterior vai atribuir o modelo Post para a coluna de banco de dados posts .

Agora, vamos programar código Eloquent dentro do seu controlador para a operação CRUD. Por exemplo, o código abaixo irá recuperar contas do modelo User com o status Active:

$activeUsers = User::where('status', 'active')->get();

Normalmente, precisamos do seguinte para realizar a mesma operação usando SQL:

$activeUsers = DB::select('SELECT * FROM users WHERE status = ?', ['active']);

O Laravel também permite que você estabeleça relações entre registros em diferentes modelos Eloquent para uma organização de dados mais eficiente. Aqui estão as conexões suportadas:

• One-to-one – um registro está associado a outro registro em um modelo diferente. Por exemplo, um nome de usuário com seu ID de usuário.
• One-to-many – um registro se conecta a múltiplos valores de um modelo. Por exemplo, um usuário de loja virtual com suas notas fiscais de compra.
• Many-to-many  – múltiplos registros se relacionam com múltiplos registros de outra tabela. Um exemplo dessa relação são produtos e etiquetas.

O Laravel também possui um recurso de migração que ajuda a manter a consistência entre bancos de dados em diferentes ambientes ou versões. Ele também permite que você crie colunas em um novo modelo com uma única execução.

Para criar um arquivo de migração para uma tabela, execute o seguinte comando:

php artisan make:migration create_example_table

Você também pode criar um arquivo de migração ao configurar um modelo adicionando a opção -m ou –migration assim:

php artisan make:model Post --migration

O Laravel vai criar um arquivo de migração dentro do diretório database/migrations. Dentro dele, especifique dois comandos –  up() e down(). A função up() define as alterações a serem feitas quando você executa o comando PHP Artisan migrate, enquanto down() especifica o método para reverter as modificações. Aqui está um exemplo do código completo:

<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
class CreatePostsTable extends Migration
{
   /**
    * Executar as migrações.
    *
    * @return void
    */
   public function up()
   {
           Schema::create('posts', function (Blueprint $table) {
           $table->id(); // Chave primária com incrementação automática
           $table->string('title'); // Coluna para o título do post
           $table->text('body'); // Coluna para o conteúdo do post
           $table->timestamps(); // Marcadores de data e hora de criação e atualização
       });
   }
   /**
    * Reverter as migrações.
    *
    * @return void
    */
   public function down()
   {
       Schema::dropIfExists('posts');
   }
}

Se você executar o seguinte comando, as funções dentro de up()  serão executadas, criando as colunas id, string, text e timestamp dentro da tabela posts .

php artisan migrate

Para reverter as alterações, execute o seguinte comando. Ele executará a função down(), removendo a tabela de posts recém-criada:

php artisan migrate:rollback

Desenvolvedores e administradores costumam migram o banco de dados ao precisar modificar os esquemas, seja durante testes, implantação ou configuração de um novo ambiente.

Implementando autenticação e autorização

Implementar um mecanismo adequado de autenticação e autorização é crucial para a integridade e segurança do seu aplicativo web. Como construir esse sistema manualmente é complicado, o Laravel oferece um conjunto de ferramentas que permite desenvolvê-lo mais facilmente.

Autenticação Laravel

O Laravel usa guards para definir o método de autenticação dos usuários e provedores para recuperar as informações da conta de um armazenamento persistente, como um banco de dados. A lógica de autenticação está localizada dentro do arquivo config/auth.php. Aqui está um exemplo:

'guards' => [
   'web' => [
       'driver' => 'session',
       'provider' => 'users',
   ],
'providers' => [
   'users' => [
       'driver' => 'eloquent',
       'model' => App\Models\User::class,
   ],
],

No exemplo acima, usamos um guard para autenticar solicitações à nossa aplicação web usando um método de sessão baseado em cookies. Ele utiliza um provedor chamado users, que usa o mecanismo Eloquent ORM para recuperar os registros da conta do modelo user.

O Laravel também oferece os kits iniciantes Jetstream e Breeze, que fornecem um sistema de autenticação pronto para uso. Recomendamos a instalação deles para obter uma compreensão básica da implementação do código, que pode ajudá-lo a configurar uma lógica personalizada mais tarde.

Autorização Laravel

A autorização do Laravel usa dois componentes: gates e policies. Os gates (portões) verificam se um usuário tem permissão para realizar uma ação específica. Enquanto isso, as policies (políticas) definem uma lógica de autorização para ações coletivas dentro do mesmo modelo.

Gates são adequados para ações únicas, enquanto policies são úteis para autorizar processos mais complicados. Dependendo das suas aplicações Laravel, você pode usar uma ou ambas.

Registre um gate usando o método boot dentro deApp/Providers/AppServiceProvider. Por exemplo, abaixo trazemos um exemplo para comparar o ID do usuário de uma conta que quer editar um post e seu autor:

use App\Models\Post;
use App\Models\User;
use Illuminate\Support\Facades\Gate;
public function boot(): void
{
   Gate::define('update-post', function (User $user, Post $post) {
       return $user->id === $post->user_id;
   });
}

Em seguida, você pode chamar o gate para seus controladores ou templates Blade e especificar a resposta com base no resultado da autorização. Por exemplo, você pode configurar sua aplicação para retornar uma mensagem quando encontrar erros de validação. Ao mesmo tempo, crie uma policy usando o comando PHP Artisan. Por exemplo, o exemplo abaixo criará a policy  PostPolicy:

php artisan make:policy PostPolicy

Então, registre-o usando o método  boot dentro de AuthServiceProvider.php. Neste exemplo, atribuímos a policy ao modelo Post:

namespace App\Providers;
use App\Models\Post;
use App\Policies\PostPolicy;
use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;
use Illuminate\Support\Facades\Gate;
class AuthServiceProvider extends ServiceProvider
{
   protected $policies = [
       Post::class => PostPolicy::class, // Registrando a policy para o modelo de post
   ];
   public function boot(): void
   {
   // Especifique o gate aqui
   }
}

Agora você pode escrever a lógica de autorização dentro do arquivo da sua nova policy, que no nosso caso é PostPolicy.php. Para aplicá-la, chame a função no seu controlador e especifique a resposta.

Manipulando formulários e validação

A capacidade do Laravel de se comunicar e autorizar bancos de dados de maneira eficiente permite que você crie formulários facilmente.

Por exemplo, vamos criar um formulário que coleta nomes de usuário e endereços de email. Para começar, crie um componente de visualização usando Blade. Aqui está um exemplo:

<!DOCTYPE html>
<html lang="pt-br">
<head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Formulário Simples</title>
</head>
<body>
   <h1>Envie Suas Informações</h1>
   @if (session('success'))
       <div style="color: green;">{{ session('success') }}</div>
   @endif

   @if ($errors->any())
       <div style="color: red;">
           <ul>
               @foreach ($errors->all() as $error)
                   <li>{{ $error }}</li>
               @endforeach
           </ul>
       </div>
   @endif

   <form action="{{ route('form.submit') }}" method="POST">
       @csrf
       <label para="name">Nome:</label>
       <input type="text" id="name" name="name" required>
       <label for="email">Email:</label>
       <input type="email" id="email" name="email" required>
       <button type="submit">Enviar</button>
   </form>
</body>
</html>

Então, adicione as rotas em web.php, especificando qual controlador irá lidar com os envios de formulário. No nosso caso, precisamos de dois, para os métodos GET e POST:

use App\Http\Controllers\FormController;

Route::get('/form', [FormController::class, 'show'])->name('form.show');
Route::post('/form-submit', [FormController::class, 'submit'])->name('form.submit');

Agora, vamos criar o controlador usando o seguinte comando:

php artisan make:controller FormController

Adicione o seguinte código ao arquivo FormController.php para configurar seu controlador, que validará a entrada do usuário e comparará os dados com as entradas do banco de dados:

namespace App\Http\Controllers;
use Illuminate\Http\Request;
use App\Models\User; // Certifique-se de importar seu modelo User
class FormController extends Controller
{
   public function show()
   {
       return view('simple-form');
   }
   public function submit(Request $request)
   {
       // Valide a entrada
       $request->validate([
           'name' => 'required|string|max:255',
           'email' => 'required|email|max:255|exists:users,email', // Verifique se o email existe
       ]);
       return redirect()->route('form.show')->with('success', 'Formulário enviado com sucesso!');
   }
}

Conforme especificado no arquivo Blade, se o nome de usuário e o email inseridos existirem no banco de dados, sua visualização de front-end retornará uma mensagem de sucesso. Caso contrário, ele vai gerar um erro.

Se você quer verificações mais completas, pode implementar um sistema de autorização usando gates e policies.

Técnicas avançadas de Laravel

Aqui estão algumas técnicas avançadas de Laravel que podem melhorar a eficiência do seu desenvolvimento de aplicativos web.

Usando a linha de comando PHP Artisan do Laravel

PHP Artisan é um aplicativo de linha de comando que permite que você interaja com o framework do seu aplicativo, automatize tarefas complexas e gerencie recursos para um processo de desenvolvimento mais eficiente. Ele vem pré-configurado com a sua instalação Laravel.

Para listar os comandos PHP Artisan disponíveis, execute o seguinte:

php artisan list

Enquanto isso, use o argumento help para verificar o manual de um comando, incluindo as opções que ele aceita. Por exemplo, execute o seguinte para verificar o utilitário migrate :

php artisan help migrate

Um dos comandos PHP Artisan mais comuns é o make, que permite criar vários itens, incluindo outro comando, controlador e middleware. Aqui está a sintaxe:

php artisan make:item [option]

Outro comando importante é o  serve, que permite que você implante sua aplicação Laravel:

php artisan serve

Você também pode gerenciar caches com o comando PHP artisan. Por exemplo, use o seguinte para limpar o seu cache de roteamento Laravel:

php artisan route:clear

Middleware

Um middleware Laravel é um software intermediário entre sua aplicação e o cliente. Ele intercepta as solicitações do usuário antes de chegarem ao seu servidor e costuma ser usado para filtrar e registrar o tráfego. O Laravel fornece middlewares pré-construídos, que você pode usar diretamente na base de código do seu aplicativo. Por padrão, eles estão localizados em app/Http/Middleware dentro do seu projeto. Para criar um novo middleware, execute o seguinte comando PHP Artisan:

php artisan make:nome-do-middleware

Então, escreva seu script PHP para definir a lógica de manipulação. Depois de terminar, você pode aplicar o middleware a uma rota específica ou globalmente, interceptando todas as solicitações e métodos HTTP.

Para aplicar seu middleware globalmente, adicione-o à propriedade $middleware dentro de app/Http/Kernel.php. Ao trabalhar com vários serviços de middleware, você pode agrupá-los para simplificar o roteamento. Para fazer isso, liste-os na propriedade $middlewareGroups dentro do arquivo Kernel.php. Considere este exemplo:

protected $middlewareGroups = [
   'custom' => [
       \App\Http\Middleware\EncryptCookies::class,
       \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
]

No trecho, o grupo custom contém dois componentes de middleware. Você pode chamá-los simultaneamente em uma rota usando o nome do grupo, assim:

Route::get('/example', function () {
   return 'Esta rota usa o grupo de middleware personalizado.';
})->middleware('custom');

Tratamento de erros e depuração

O Laravel vem com um mecanismo de tratamento de erros que ajuda você a resolver problemas de forma mais flexível. Para configurar um manipulador de exceções personalizado, adicione a lógica dentro da classe App\Exceptions\Handler.

Você pode usar diferentes métodos para modificar como o Laravel exibirá uma exceção. Por exemplo, o seguinte código usa  render() para exibir erros específicos como respostas HTTP:

public function render($request, Throwable $exception)
{
   if ($exception instanceof CustomException) {
       return response()->view('errors.custom', [], 500);
   }

   return parent::render($request, $exception);
}

Outro método é o report(), que modifica como o Laravel registra erros no diretório storage/logs. Você também pode criar uma classe de exceção personalizada estendendo a classe base Exception, como neste código:

namespace App\Exceptions;

use Exception;

class CustomException extends Exception
{
   // Lógica ou propriedades personalizadas
}

Além de permitir que você capture exceções de forma mais eficiente, o Laravel fornece ferramentas para depurar erros. Por exemplo, o dd() e odump() permitem que você verifique os valores de uma variável, permitindo que você veja se a saída está correta:

dd($variable)

Como alternativa, você pode usar uma solução de terceiros, como o Laravel Debugbar, que fornece uma interface gráfica no seu navegador que exibe informações úteis sobre sua aplicação. Por exemplo, você pode verificar suas rotas, consultas e solicitações.

Você pode instalar essa ferramenta via Composer. Se você quer aprender mais sobre ele, confira o repositório GitHub do Laravel Debugbar.

Construindo APIs RESTful com Laravel

A interface de programação de aplicações (API) RESTful permite que as aplicações se comuniquem usando métodos HTTP como GET, POST, e DELETE. Ele permite que você integre serviços, compartilhe dados ou configure ferramentas de terceiros (como monitoramento) com mais facilidade.

O mecanismo robusto de roteamento e controle do Laravel torna-o adequado para o desenvolvimento de uma API RESTful. Saiba como:

• Abra o arquivo  routes/api.php. Ele vem com a sua instalação do Laravel por padrão.
• Defina a rota para cada endpoint da API especificando quais métodos HTTP correspondem a uma ação. Veja um exemplo:

use App\Http\Controllers\ItemController;
Route::get('/items', [ItemController::class, 'index']);

• Crie um controlador para lidar com as solicitações de todos os endpoints:

php artisan make:controller ItemController

• Defina os métodos que o ItemController usará para lidar com a operação CRUD:

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\Item;

class ItemController extends Controller
{
   // GET /items
   public function index()
   {
       return Item::all();
   }

• Crie um modelo e um arquivo de migração de banco de dados para armazenar os dados do aplicativo para o recurso  Item :

php artisan make:model Item -m

• Defina a estrutura da sua tabela de itens no banco de dados adicionando o seguinte código:

public function up()
{
   Schema::create('items', function (Blueprint $table) {
       $table->id();
       $table->string('name');
       $table->timestamps();
   });
}

• Execute a migração para configurar a tabela do banco de dados:

php artisan migrate

Agora, verifique se o endpoint do API funciona corretamente enviando uma solicitação GET usando cURL ou Postman.

Conclusão

O Laravel é um framework de desenvolvimento de aplicativos PHP full-stack que fornece várias ferramentas para simplificar o trabalho dos desenvolvedores web. Por exemplo, o template Blade permite que você integre PHP ao HTML de maneira perfeita, enquanto o kit inicial Breeze simplifica a criação de sistemas de autenticação.

Neste artigo, explicamos ferramentas e conceitos importantes no Laravel. Aqui está um breve resumo:

• PHP Artisan – ferramenta de linha de comando para criar e gerenciar componentes de aplicativos Laravel.
• Rotas – um sistema que redireciona solicitações de usuários para um controlador específico com base na solicitação HTTP para processamento.
• Controlador – uma lógica que lida com as operações CRUD com base nas solicitações dos clientes.
• Modelo – um método que permite que os controladores interajam com esquemas de uma tabela de banco de dados específica.
• Visualizações – a interface de front-end do seu aplicativo, usada para receber entradas e mostrar saídas.

Para se familiarizar com o Laravel, recomendamos criar um projeto do zero para praticar. Se você usa algum plano VPS da Hostinger, pode pedir ajuda ao nosso Assistente com IA, o Kodee, para garantir um processo de aprendizado tranquilo.

Tutorial Laravel: perguntas frequentes

Por fim, vamos responder algumas perguntas frequentes feitas por quem está querendo adentrar no universo do Laravel.