CHEAT SHEET COMPLETO LARAVEL 10 PTBR
Tags: laravel, webdev, beginners, braziliandevs
Published: 2023-05-19 17:41:02

```
<?

// Rotas básicas
Route::get('/rota', 'Controller@metodo');
Route::post('/rota', 'Controller@metodo');
Route::put('/rota', 'Controller@metodo');
Route::delete('/rota', 'Controller@metodo');

// Rotas com parâmetros
Route::get('/rota/{param}', 'Controller@metodo');

// Parâmetros opcionais
Route::get('/rota/{param?}', 'Controller@metodo');

// Restrições de parâmetros
Route::get('/rota/{param}', 'Controller@metodo')->where('param', '[0-9]+');

// Rotas nomeadas
Route::get('/rota', 'Controller@metodo')->name('nome.rota');

// Prefixo de grupo de rotas
Route::prefix('admin')->group(function () {
    Route::get('/rota1', 'Controller@metodo1');
    Route::get('/rota2', 'Controller@metodo2');
});

// Middleware nas rotas
Route::get('/rota', 'Controller@metodo')->middleware('auth');

// Middleware em grupo de rotas
Route::middleware(['auth'])->group(function () {
    Route::get('/rota1', 'Controller@metodo1');
    Route::get('/rota2', 'Controller@metodo2');
});

// Prefixo e middleware em grupo de rotas
Route::prefix('admin')->middleware('auth')->group(function () {
    Route::get('/rota1', 'Controller@metodo1');
    Route::get('/rota2', 'Controller@metodo2');
});

// Rotas API com prefixo e versão
Route::prefix('api')->version('v1')->group(function () {
    Route::get('/rota1', 'Controller@metodo1');
    Route::get('/rota2', 'Controller@metodo2');
});

// Agrupamento de rotas para recursos RESTful
Route::resource('recurso', 'RecursoController');

// Rotas específicas de recursos RESTful
Route::get('/recurso/{id}/metodo', 'RecursoController@metodo');
Route::post('/recurso/{id}/metodo', 'RecursoController@metodo');
Route::put('/recurso/{id}/metodo', 'RecursoController@metodo');
Route::delete('/recurso/{id}/metodo', 'RecursoController@metodo');

// Rotas para recursos RESTful sem algumas ações
Route::resource('recurso', 'RecursoController')->except(['create', 'edit']);

// Middleware para recursos RESTful
Route::resource('recurso', 'RecursoController')->middleware('auth');

// Prefixo para recursos RESTful
Route::prefix('admin')->group(function () {
    Route::resource('recurso', 'RecursoController');
});

// Rotas aninhadas
Route::prefix('pais/{id_pais}')->group(function () {
    Route::get('/estado/{id_estado}', 'Controller@metodo');
    Route::get('/estado/{id_estado}/cidade/{id_cidade}', 'Controller@metodo');
});

// Closure como controlador
Route::get('/rota', function () {
    return 'Hello World!';
});

// Closure com parâmetro
Route::get('/rota/{param}', function ($param) {
    return "Parâmetro: " . $param;
});

// Redirecionamento de rota
Route::redirect('/rota1', '/rota2');

// Redirecionamento com código de status
Route::redirect('/rota1', '/rota2', 301);

// Redirecionamento para um nome de rota
Route::redirect('/rota1', route('nome.rota2'));

// View de rota
Route::view('/rota', 'nome_da_view');

// Grupos de middleware
Route::middleware(['middleware1', 'middleware2'])->group(function () {
    Route::get('/rota1', 'Controller@metodo1');
    Route::get('/rota2', 'Controller@metodo2');
});






// Comandos básicos
php artisan list                    // Listar todos os comandos disponíveis
php artisan help nome_comando       // Obter ajuda para um comando específico

// Criação de arquivos e classes
php artisan make:model NomeModelo               // Criar um novo modelo
php artisan make:model NomeModelo -m            // Criar um novo modelo com uma migration
php artisan make:controller NomeControlador     // Criar um novo controlador
php artisan make:middleware NomeMiddleware     // Criar um novo middleware
php artisan make:seeder NomeSeeder               // Criar um novo seeder
php artisan make:factory NomeFactory             // Criar uma nova factory
php artisan make:resource NomeResource           // Criar uma nova resource
php artisan make:request NomeRequest             // Criar um novo request

// Migration
php artisan migrate                // Executar todas as migrations pendentes
php artisan migrate:install       // Criar a tabela de controle das migrations
php artisan migrate:rollback      // Reverter a última migration executada
php artisan migrate:reset         // Reverter todas as migrations executadas
php artisan migrate:refresh      // Reverter e executar todas as migrations novamente
php artisan migrate:status        // Verificar o status das migrations

// Seed
php artisan db:seed                  // Executar todos os seeders
php artisan db:seed --class=NomeSeeder    // Executar um seeder específico

// Rotas
php artisan route:list           // Listar todas as rotas registradas

// Tarefas em segundo plano (Jobs)
php artisan queue:work                 // Iniciar o worker da fila
php artisan queue:listen               // Escutar a fila para processar os jobs
php artisan queue:failed                // Listar os jobs que falharam
php artisan queue:retry ID               // Tentar novamente um job falhado
php artisan queue:forget ID             // Remover um job falhado da lista
php artisan queue:flush                  // Limpar todos os jobs falhados

// Cache
php artisan cache:clear            // Limpar o cache
php artisan config:cache           // Limpar e recompilar as configurações
php artisan route:cache             // Limpar e recompilar as rotas

// Servidor de desenvolvimento
php artisan serve                  // Iniciar o servidor de desenvolvimento

// Tinker (REPL)
php artisan tinker                // Iniciar o console interativo Tinker

// Testes
php artisan test                   // Executar os testes

// Gerar chave de aplicativo
php artisan key:generate        // Gerar uma nova chave de aplicativo

// Outros comandos úteis
php artisan optimize              // Otimizar a aplicação para melhor desempenho
php artisan down                   // Colocar a aplicação em modo de manutenção
php artisan up                       // Desativar o modo de manutenção



//Eloquent ORM
// Definindo um modelo
class UserModel extends Model {
    protected $table = 'users';        // Nome da tabela
    protected $primaryKey = 'id';      // Chave primária
    protected $fillable = ['name', 'email', 'password'];   // Colunas preenchíveis em massa
    protected $guarded = ['id'];       // Colunas protegidas contra atribuição em massa
    public $timestamps = true;         // Utilizar timestamps
}

// Consultas básicas
$user = User::find($id);               // Buscar um registro pelo ID
$users = User::all();                  // Buscar todos os registros
$users = User::where('name', 'John')->get();    // Buscar registros com uma condição
$user = User::first();                 // Buscar o primeiro registro
$user = User::orderBy('name', 'asc')->first();   // Buscar o primeiro registro ordenado
$count = User::count();                // Contar o número de registros

// Consultas avançadas
$users = User::where('votes', '>', 100)->orWhere('name', 'John')->get();   // Condições combinadas
$users = User::whereBetween('votes', [1, 100])->get();   // Buscar registros com valor entre um intervalo
$users = User::whereIn('id', [1, 2, 3])->get();   // Buscar registros com valores em uma lista
$users = User::whereNull('updated_at')->get();   // Buscar registros onde um campo é nulo
$users = User::whereNotNull('updated_at')->get();   // Buscar registros onde um campo não é nulo

// Inserção de registros
$user = new User;
$user->name = 'John';
$user->email = 'john@example.com';
$user->save();

// Atualização de registros
$user = User::find($id);
$user->name = 'John Doe';
$user->save();

// Exclusão de registros
$user = User::find($id);
$user->delete();

// Relacionamentos
class User extends Model {
    public function posts() {
        return $this->hasMany(Post::class);
    }
}

class Post extends Model {
    public function user() {
        return $this->belongsTo(User::class);
    }
}

$user = User::find($id);
$posts = $user->posts;                 // Obter os posts relacionados de um usuário

$post = Post::find($id);
$user = $post->user;                   // Obter o usuário relacionado a um post

// Consultas de relacionamento
$user = User::with('posts')->find($id);   // Buscar um usuário com seus posts relacionados

// Consultas avançadas de relacionamento
$users = User::whereHas('posts', function ($query) {
    $query->where('votes', '>', 100);
})->get();   // Buscar usuários que têm posts com mais de 100 votos

// Ordenação de relacionamento
$user = User::with(['posts' => function ($query) {
    $query->orderBy('created_at', 'desc');
}])->find($id);   // Buscar um usuário com seus posts relacionados ordenados


// Validação de Dados
$dadosValidados = $request->validate([
    'campo1' => 'required',
    'campo2' => 'numeric',
]);

$regras = [
    'campo1' => 'required',
    'campo2' => 'numeric',
];
$mensagens = [
    'campo1.required' => 'Campo 1 é obrigatório',
];
$dadosValidados = $request->validate($regras, $mensagens);






{{-- Exibir uma seção em um template --}}
@yield('name')

{{-- Estender um layout --}}
@extends('layout.name')

{{-- Iniciar uma seção --}}
@section('name')
{{-- Conteúdo da seção --}}
@endsection

{{-- Finalizar uma seção e exibir o conteúdo --}}
@section('sidearg1')
@show

{{-- Exibir o conteúdo da seção pai --}}
@parent

{{-- Incluir uma view --}}
@include('view.name')

{{-- Incluir uma view com dados --}}
@include('view.name', array('key' => 'value'))

{{-- Traduzir uma mensagem --}}
@lang('messages.name')

{{-- Traduzir uma mensagem com contagem --}}
@choice('messages.name', 1)

{{-- Estrutura condicional "if" --}}
@if(condition)
    {{-- Código --}}
@elseif(condition)
    {{-- Código --}}
@else
    {{-- Código --}}
@endif

{{-- Estrutura condicional "unless" --}}
@unless(condition)
    {{-- Código --}}
@endunless

{{-- Loop "for" --}}
@for($i = 0; $i < $count; $i++)
    {{-- Código --}}
@endfor

{{-- Loop "foreach" --}}
@foreach($items as $item)
    {{-- Código --}}
@endforeach

{{-- Loop "while" --}}
@while(condition)
    {{-- Código --}}
@endwhile

{{-- Loop "forelse" --}}
@forelse($users as $user)
    {{-- Código --}}
@empty
    {{-- Código --}}
@endforelse

{{-- Exibir conteúdo --}}
{{ $var }}

{{-- Exibir conteúdo escapado --}}
{{{ $var }}}

{{-- Exibir conteúdo não escapado --}}
{!! $var !!}

{{-- Comentário Blade --}}
{{-- Conteúdo do comentário --}}

{{-- Exibir dados após verificar a existência --}}
{{ $name or 'Padrão' }}

{{-- Exibir texto bruto com chaves --}}
@{{ Isso não será processado pelo Blade }}

// Obter a URL completa da requisição atual
URL::full();

// Obter a URL atual
URL::current();

// Obter a URL anterior
URL::previous();

// Gerar uma URL para uma rota ou caminho específico
URL::to('arg/arg1', $parameters, $secure);

// Gerar uma URL para uma ação de um controlador
URL::action('UserController@item', ['id'=>123]);

// Precisa ser no namespace apropriado
URL::action('Auth\AuthController@logout');

// Gerar uma URL para um método de um controlador específico
URL::action('argController@method', $parameters, $absolute);

// Gerar uma URL para uma rota nomeada
URL::route('arg', $parameters, $absolute);

// Gerar uma URL segura
URL::secure('arg1/arg2', $parameters);

// Gerar o caminho para um recurso estático (CSS, JavaScript, imagens, etc.)
URL::asset('css/arg.css', $secure);

// Gerar o caminho para um recurso estático seguro (HTTPS)
URL::secureAsset('css/arg.css');

// Verificar se uma URL é válida
URL::isValidUrl('http://example.com');

// Obter a instância da requisição atual
URL::getRequest();

// Definir a instância da requisição atual
URL::setRequest($request);

// Registrar uma nova macro para o HTML
HTML::macro('name', function(){});

// Converter uma string HTML em entidades
HTML::entities($value);

// Converter entidades em caracteres HTML
HTML::decode($value);

// Gerar um link para um arquivo JavaScript
HTML::script($url, $attributes);

// Gerar um link para um arquivo CSS
HTML::style($url, $attributes);

// Gerar um elemento de imagem HTML
HTML::image($url, $alt, $attributes);

// Gerar um link HTML
HTML::link($url, 'title', $attributes, $secure);

// Gerar um link HTML seguro (HTTPS)
HTML::secureLink($url, 'title', $attributes);

// Gerar um link HTML para um recurso estático
HTML::linkAsset($url, 'title', $attributes, $secure);

// Gerar um link HTML seguro (HTTPS) para um recurso estático
HTML::linkSecureAsset($url, 'title', $attributes);

// Gerar um link HTML para uma rota nomeada
HTML::linkRoute($name, 'title', $parameters, $attributes);

// Gerar um link HTML para uma ação de um controlador
HTML::linkAction($action, 'title', $parameters, $attributes);

// Gerar um link HTML para um endereço de e-mail
HTML::mailto($email, 'title', $attributes);

// Ofuscar um endereço de e-mail para evitar spam-bots
HTML::email($email);

// Gerar uma lista ordenada de itens
HTML::ol($list, $attributes);

// Gerar uma lista não ordenada de itens
HTML::ul($list, $attributes);

// Criar um elemento HTML de lista
HTML::listing($type, $list, $attributes);

// Criar o HTML para um elemento de lista aninhado
HTML::listingElement($key, $type, $value);

// Criar o HTML para um atributo aninhado em uma lista
HTML::nestedListing($key, $type, $value);

// Construir uma string de atributos HTML a partir de um array
HTML::attributes($attributes);

// Construir um elemento de atributo HTML único
HTML::attributeElement($key, $value);

// Ofuscar uma string para evitar spam-bots
HTML::obfuscate($value);


// Restaurar os registros excluídos logicamente (soft deletes) que atendem à condição
Model::withTrashed()->where('users', 2)->restore();

// Excluir permanentemente os registros que atendem à condição, mesmo que sejam soft deletes
Model::where('users', 2)->forceDelete();

// Forçar o conjunto de resultados a incluir apenas registros excluídos logicamente (soft deletes)
Model::onlyTrashed()->where('users', 2)->get();

// Eventos do Modelo (Model Events)

// Evento disparado antes de criar um novo modelo
Model::creating(function($model){});

// Evento disparado depois de criar um novo modelo
Model::created(function($model){});

// Evento disparado antes de atualizar um modelo existente
Model::updating(function($model){});

// Evento disparado depois de atualizar um modelo existente
Model::updated(function($model){});

// Evento disparado antes de salvar um modelo (inserir ou atualizar)
Model::saving(function($model){});

// Evento disparado depois de salvar um modelo (inserir ou atualizar)
Model::saved(function($model){});

// Evento disparado antes de excluir um modelo
Model::deleting(function($model){});

// Evento disparado depois de excluir um modelo
Model::deleted(function($model){});

// Observar um modelo com um observador personalizado (argObserver)
Model::observe(new argObserver);

// Joins no Laravel

// Join Statement
DB::table('users')
    ->join('contacts', 'users.id', '=', 'contacts.user_id') // Realiza um join entre as tabelas 'users' e 'contacts' usando a coluna 'id' da tabela 'users' e 'user_id' da tabela 'contacts'
    ->join('orders', 'users.id', '=', 'orders.user_id') // Realiza um join entre as tabelas 'users' e 'orders' usando a coluna 'id' da tabela 'users' e 'user_id' da tabela 'orders'
    ->select('users.id', 'contacts.phone', 'orders.price') // Seleciona as colunas 'users.id', 'contacts.phone' e 'orders.price'
    ->get(); // Executa a consulta e retorna os resultados

// Left Join Statement
DB::table('users')
    ->leftJoin('posts', 'users.id', '=', 'posts.user_id') // Realiza um left join entre as tabelas 'users' e 'posts' usando a coluna 'id' da tabela 'users' e 'user_id' da tabela 'posts'
    ->get(); // Executa a consulta e retorna os resultados

// Consulta com condições e agrupamento
DB::table('users')
    ->where('name', '=', 'John') // Condição: coluna 'name' deve ser igual a 'John'
    ->orWhere(function ($query) {
        $query->where('votes', '>', 100) // Condição aninhada: coluna 'votes' deve ser maior que 100
            ->where('title', '<>', 'Admin'); // Condição aninhada: coluna 'title' deve ser diferente de 'Admin'
    })
    ->get(); // Executa a consulta e retorna os resultados


// Agregações
$users = DB::table('game')->count(); // Conta o número de registros na tabela 'game'
$price = DB::table('game')->max('points'); // Retorna o valor máximo da coluna 'points' na tabela 'game'
$price = DB::table('game')->min('points'); // Retorna o valor mínimo da coluna 'points' na tabela 'game'
$price = DB::table('game')->avg('points'); // Retorna a média dos valores da coluna 'points' na tabela 'game'
$total = DB::table('game')->sum('points'); // Retorna a soma dos valores da coluna 'points' na tabela 'game'

// Expressões Raw
DB::table('name')->remember(5)->get(); // Recupera os registros da tabela 'name' e os armazena em cache por 5 minutos
DB::table('name')->remember(5, 'cache-key-name')->get(); // Recupera os registros da tabela 'name' e os armazena em cache com uma chave personalizada por 5 minutos
DB::table('name')->cacheTags('my-key')->remember(5)->get(); // Recupera os registros da tabela 'name' e os armazena em cache com uma tag específica por 5 minutos
DB::table('name')->cacheTags(['my-first-key', 'my-second-key'])->remember(5)->get(); // Recupera os registros da tabela 'name' e os armazena em cache com várias tags por 5 minutos

$users = DB::table('users')
    ->select(DB::raw('count(*) as user_count, status'))
    ->where('status', '<>', 1)
    ->groupBy('status')
    ->get(); // Seleciona o número de registros e o status da tabela 'users', agrupados por status, onde o status não é igual a 1

// Consultas com SQL puro
DB::select('SELECT * FROM users WHERE id = ?', [value]); // Executa uma consulta SQL personalizada com um parâmetro

// Inserções, atualizações, exclusões e unions

// Inserção
DB::table('users')->insert([
    'email' => 'email@host.com',
    'votes' => 0
]); // Insere um novo registro na tabela 'users' com os valores especificados

$id = DB::table('users')->insertGetId([
    'email' => 'email@host.com',
    'votes' => 0
]); // Insere um novo registro na tabela 'users' e retorna o ID gerado

DB::table('users')->insert([
    ['email' => 'email1@host.com', 'votes' => 0],
    ['email' => 'email2@host.com', 'votes' => 0]
]); // Insere vários registros na tabela 'users'

// Atualização
DB::table('users')
    ->where('id', 1)
    ->update(['votes' => 1]); // Atualiza os registros na tabela 'users' onde o ID é igual a 1, definindo o valor da coluna 'votes' como 1

DB::table('users')->increment('votes'); // Incrementa o valor da coluna 'votes' em 1 para todos os registros da tabela 'users'
DB::table('users')->increment('votes', 5); // Incrementa o valor da coluna 'votes' em 5 para todos os registros da tabela 'users'
DB::table('users')->decrement('votes'); // Decrementa o valor da coluna 'votes' em 1 para todos os registros da tabela 'users'
DB::table('users')->decrement('votes', 5); // Decrementa o valor da coluna 'votes' em 5 para todos os registros da tabela 'users'
DB::table('users')->increment('votes', 1, ['name' => 'Name']); // Incrementa o valor da coluna 'votes' em 1 e atualiza o valor da coluna 'name' para 'Name' para todos os registros da tabela 'users'

// Exclusão
DB::table('users')->where('votes', '<', 100)->delete(); // Exclui os registros da tabela 'users' onde o valor da coluna 'votes' é menor que 100
DB::table('users')->delete(); // Exclui todos os registros da tabela 'users'
DB::table('users')->truncate(); // Esvazia a tabela 'users', excluindo todos os registros

// Union
$first = DB::table('users')->whereNull('first_name'); // Seleciona os registros da tabela 'users' onde o valor da coluna 'first_name' é nulo
$users = DB::table('users')->whereNull('last_name')->union($first)->get(); // Seleciona os registros da tabela 'users' onde o valor da coluna 'last_name' é nulo e une-os aos registros selecionados anteriormente

// Pessimistic Locking
DB::table('users')->where('votes', '>', 100)->sharedLock()->get(); // Seleciona os registros da tabela 'users' onde o valor da coluna 'votes' é maior que 100 e adquire um bloqueio compartilhado
DB::table('users')->where('votes', '>', 100)->lockForUpdate()->get(); // Seleciona os registros da tabela 'users' onde o valor da coluna 'votes' é maior que 100 e adquire um bloqueio exclusivo para atualização


// Laravel Auth

// Determine se o usuário atual está autenticado
Auth::check();

// Obtenha o usuário atualmente autenticado
Auth::user();

// Obtenha o ID do usuário atualmente autenticado
Auth::id();

// Tente autenticar um usuário usando as credenciais fornecidas
Auth::attempt(array('email' => $email, 'password' => $password));

// "Lembrar de mim" passando true para Auth::attempt()
Auth::attempt($credentials, true);

// Faça login apenas para uma única requisição
Auth::once($credentials);

// Faça login de um usuário na aplicação
Auth::login(User::find(1));

// Faça login com o ID de usuário fornecido na aplicação
Auth::loginUsingId(1);

// Faça logout do usuário na aplicação
Auth::logout();

// Valide as credenciais de um usuário
Auth::basic('username');

// Tente autenticar usando o HTTP Basic Auth
Auth::validate($credentials);

// Faça uma tentativa de login HTTP Basic sem estado
Auth::onceBasic();

// Envie um lembrete de senha para um usuário
Password::remind($credentials, function($message, $user){});

// Laravel Authorization

// Defina habilidades
Gate::define('update-post', 'Classe@método');
Gate::define('update-post', function ($user, $post) {...});

// Passando vários argumentos
Gate::define('delete-comment', function ($user, $post, $comment) {});

// Verifique habilidades
Gate::denies('update-post', $post);
Gate::allows('update-post', $post);
Gate::check('update-post', $post);

// Especificar um usuário para verificação
Gate::forUser($user)->allows('update-post', $post);

// Através do modelo de usuário, usando o trait Authorizable
User::find(1)->can('update-post', $post);
User::find(1)->cannot('update-post', $post);

// Interceptando verificações de autorização
Gate::before(function ($user, $ability) {});
Gate::after(function ($user, $ability) {});

// Verificando em um template Blade
@can('update-post', $post)
@endcan
// com else
@else
@endcan

// Gerar uma Política
php artisan make:policy PostPolicy

// Função auxiliar `policy`
policy($post)->update($user, $post)

// Autorização no Controller
$this->authorize('update', $post);

// Para $user
$this->authorizeForUser($user, 'update', $post);

// Paginação

// Paginação automática
Model::paginate(15);
Model::where('cars', 2)->paginate(15);

// Somente "Próximo" e "Anterior"
Model::where('cars', 2)->simplePaginate(15);

// Paginador manual
Paginator::make($items, $totalItems, $perPage);

// Imprimir navegadores de página na visualização
$variable->links();

```