Files
reference/source/_posts/laravel.md
T
2022-12-30 10:47:54 +08:00

1466 lines
32 KiB
Markdown

---
title: Laravel
date: 2021-11-09 18:26:55
background: bg-[#e44230]
label: PHP
tags:
- web
- framework
- php
categories:
- Programming
intro: |
[Laravel](https://laravel.com/docs/8.x/) is an expressive and progressive web application framework for PHP.
This cheat sheet provides a reference for common commands and features for Laravel 8.
---
Getting Started
---------------
### Requirements {.row-span-2}
- PHP version >= 7.3
- BCMath PHP Extension
- Ctype PHP Extension
- Fileinfo PHP Extension
- JSON PHP Extension
- Mbstring PHP Extension
- OpenSSL PHP Extension
- PDO PHP Extension
- Tokenizer PHP Extension
- XML PHP Extension
Ensure your web server directs all requests to your application's
`public/index.php` file, See: [Deployment](#deployment)
### Windows
- #### Install [Docker Desktop](https://www.docker.com/products/docker-desktop)
- #### Install & enable [WSL2](https://docs.microsoft.com/en-us/windows/wsl/install)
- #### Ensure that Docker Desktop is [configured to use WSL2](https://docs.docker.com/desktop/windows/wsl/)
- #### In WSL2 terminal:
```shell
$ curl -s https://laravel.build/example-app | bash
$ cd example-app
$ ./vendor/bin/sail up
```
{.marker-timeline}
Access application via `http://localhost`
### Mac
- #### Install [Docker Desktop](https://www.docker.com/products/docker-desktop)
- #### In terminal:
```shell
$ curl -s https://laravel.build/example-app | bash
$ cd example-app
$ ./vendor/bin/sail up
```
{.marker-timeline}
Access application via `http://localhost`
### Linux
```shell
$ curl -s https://laravel.build/example-app | bash
$ cd example-app
$ ./vendor/bin/sail up
```
Installation via [Composer](https://getcomposer.org)
```bash
$ composer create-project laravel/laravel example-app
$ cd example-app
$ php artisan serve
```
Access application via `http://localhost`
Configuration
---------------
### .env {.cols-2}
Retrieve values from `.env` file
```php
env('APP_DEBUG');
// with default value
env('APP_DEBUG', false);
```
Determine current environment
```php
use Illuminate\Support\Facades\App;
$environment = App::environment();
```
Accessing configuration values using "dot" syntax
```php
// config/app.php --> ['timezone' => '']
$value = config('app.timezone');
// Retrieve a default value if the configuration value does not exist...
$value = config('app.timezone', 'Asia/Seoul');
```
Set configuration values at runtime:
```php
config(['app.timezone' => 'America/Chicago']);
```
### Debug Mode
Turn on (local dev):
```php
// .env file
APP_ENV=local
APP_DEBUG=true
// ...
```
Turn off (production):
```php
// .env file
APP_ENV=production
APP_DEBUG=false
// ...
```
### Maintenance Mode
Temporarily disable application (503 status code)
```bash
php artisan down
```
#### Disable maintenance mode
```bash
php artisan up
```
#### Bypass Maintenance Mode
```bash
php artisan down --secret="1630542a-246b-4b66-afa1-dd72a4c43515"
```
Visit your application URL `https://example.com/1630542a-246b-4b66-afa1-dd72a4c43515` to set a cookie and bypass the maintenance screen
Routing
---------------
### Router HTTP Methods {.row-span-2}
```php
Route::get($uri, $callback);
Route::post($uri, $callback);
Route::put($uri, $callback);
Route::patch($uri, $callback);
Route::delete($uri, $callback);
Route::options($uri, $callback);
```
Multiple HTTP methods
```php
Route::match(['get', 'post'], '/', function () {
//
});
Route::any('/', function () {
//
});
```
### Basic Definition {.row-span-2}
```php
use Illuminate\Support\Facades\Route;
// closure
Route::get('/greeting', function () {
return 'Hello World';
});
// controller action
Route::get(
'/user/profile',
[UserProfileController::class, 'show']
);
```
### Dependency Injection
```php
use Illuminate\Http\Request;
Route::get('/users', function (Request $request) {
// ...
});
```
Type hint concrete dependencies for auto-injection
### View Routes
```php
// Argument 1: URI, Argument 2: view name
Route::view('/welcome', 'welcome');
// with data
Route::view('/welcome', 'welcome', ['name' => 'Taylor']);
```
Route only needs to return a view.
### Route Model Binding {.row-span-4}
#### Implicit binding
With closure
```php
use App\Models\User;
Route::get('/users/{user}', function (User $user) {
return $user->email;
});
// /user/1 --> User::where('id', '=', 1);
```
With controller action
```php
use App\Http\Controllers\UserController;
use App\Models\User;
// Route definition...
Route::get('/users/{user}', [UserController::class, 'show']);
// Controller method definition...
public function show(User $user)
{
return view('user.profile', ['user' => $user]);
}
```
With custom resolution column
```php
use App\Models\Post;
Route::get('/posts/{post:slug}', function (Post $post) {
return $post;
});
// /posts/my-post --> Post::where('slug', '=', 'my-post');
```
Always use a different column to resolve
```php
// in App\Models\Post
public function getRouteKeyName()
{
return 'slug';
}
```
Multiple models - second is child of first
```php
use App\Models\Post;
use App\Models\User;
Route::get('/users/{user}/posts/{post:slug}', function (User $user, Post $post) {
return $post;
});
```
Convenient way to automatically inject the model instances directly into your routes
### Route Parameters {.row-span-2}
Capture segments of the URI within your route
#### Required parameters
```php
Route::get('/user/{id}', function ($id) {
return 'User '.$id;
});
```
With dependency injection
```php
use Illuminate\Http\Request;
Route::get('/user/{id}', function (Request $request, $id) {
return 'User '.$id;
});
```
#### Optional Parameters
```php
Route::get('/user/{name?}', function ($name = null) {
return $name;
});
Route::get('/user/{name?}', function ($name = 'John') {
return $name;
});
```
### Redirect Routes
HTTP `302` status
```php
Route::redirect('/here', '/there');
```
Set the status code
```php
Route::redirect('/here', '/there', 301);
```
Permanent `301` redirect
```php
Route::permanentRedirect('/here', '/there');
```
### Regular Expression Constraints {.cols-2}
```php
Route::get('/user/{name}', function ($name) {
//
})->where('name', '[A-Za-z]+');
Route::get('/user/{id}', function ($id) {
//
})->where('id', '[0-9]+');
Route::get('/user/{id}/{name}', function ($id, $name) {
//
})->where(['id' => '[0-9]+', 'name' => '[a-z]+']);
```
See also: [Regex Cheatsheet](/regex)
### Named Routes
Route names should always be unique
```php
Route::get('/user/profile', function () {
//
})->name('profile');
```
See: [Helpers](#helpers-cols-3)
### Fallback Routes
```php
Route::fallback(function () {
//
});
```
Executed when no other routes match
### Route Groups
#### Middleware
```php
Route::middleware(['first', 'second'])->group(function () {
Route::get('/', function () {
// Uses first & second middleware...
});
Route::get('/user/profile', function () {
// Uses first & second middleware...
});
});
```
#### URI Prefixes
```php
Route::prefix('admin')->group(function () {
Route::get('/users', function () {
// Matches The "/admin/users" URL
});
});
```
#### Name Prefix
```php
Route::name('admin.')->group(function () {
Route::get('/users', function () {
// Route assigned name "admin.users"...
})->name('users');
});
```
Share attributes across routes
### Accessing current route
```php
use Illuminate\Support\Facades\Route;
// Illuminate\Routing\Route
$route = Route::current();
// string
$name = Route::currentRouteName();
// string
$action = Route::currentRouteAction();
```
Helpers
---------------
### routes {.row-span-2}
#### Named route
```php
$url = route('profile');
```
With parameters
```php
// Route::get('/user/{id}/profile', /*...*/ )->name('profile);
$url = route('profile', ['id' => 1]);
// /user/1/profile/
```
With query string
```php
// Route::get('/user/{id}/profile', /*...*/ )->name('profile);
$url = route('profile', ['id' => 1, 'photos'=>'yes']);
// /user/1/profile?photos=yes
```
#### Redirects
```php
// Generating Redirects...
return redirect()->route('profile');
```
#### Eloquent Models
```php
echo route('post.show', ['post' => $post]);
```
The route helper will automatically extract the model's route key.
See [Routing](#routing-cols-4)
### URL Generation
Generate arbitrary URLs for your application that will
automatically use the scheme (HTTP or HTTPS) and host
from the current request
```php
$post = App\Models\Post::find(1);
echo url("/posts/{$post->id}");
// http://example.com/posts/1
```
#### Current URL
```php
// Get the current URL without the query string...
echo url()->current();
// Get the current URL including the query string...
echo url()->full();
// Get the full URL for the previous request...
echo url()->previous();
```
### Named Route URL
```php
$url = route('profile');
```
See [Named Route](#named-route)
### Error Handling
```php
public function isValid($value)
{
try {
// Validate the value...
} catch (Throwable $e) {
report($e);
return false;
}
}
```
Report an exception but continue handling the current request
### HTTP Exceptions
```php
// page not found
abort(404);
```
Generate an HTTP exception response using status code
Controllers
---------------
### Basic
```php
namespace App\Http\Controllers;
use App\Http\Controllers\Controller;
use App\Models\User;
class UserController extends Controller
{
public function show($id)
{
return view('user.profile', [
'user' => User::findOrFail($id)
]);
}
}
```
Define a route for this controller method:
```php
use App\Http\Controllers\UserController;
Route::get('/user/{id}', [UserController::class, 'show']);
```
Requests
---------------
### CSRF Protection
Laravel automatically generates a CSRF "token" for each active user session.
This token is used to verify that the authenticated user is the person actually making the requests.
Get current session's token:
```php
Route::get('/token', function (Request $request) {
$token = $request->session()->token();
$token = csrf_token();
// ...
});
```
`POST`, `PUT`, `PATCH`, or `DELETE` forms should include a hidden CSRF `_token` field
in the form to validate the request.
```html
<form method="POST" action="/profile">
@csrf
<!-- Equivalent to... -->
<input type="hidden" name="_token" value="{{ csrf_token() }}" />
</form>
```
See [Forms](#forms-cols-3)
### Accessing Request
Get an instance of the current request by type-hinting the
controller action or route closure
```php
// controller action
class UserController extends Controller
{
public function store(Request $request)
{
$name = $request->input('name');
}
}
// closure
Route::get('/', function (Request $request) {
//
});
```
[See Routing](#routing)
### Path
The request's path information
```php
$uri = $request->path();
// https://example.com/foo/bar --> foo/bar
```
#### Match path to pattern
Verify that the incoming request path matches a given pattern
```php
// * is wildcard
if ($request->is('admin/*')) {
//
}
```
Determine if the incoming request matches a named route
```php
if ($request->routeIs('admin.*')) {
//
}
```
### URL
Full URL for the incoming request
```php
// URL without the query string
$url = $request->url();
// URL including query string
$urlWithQueryString = $request->fullUrl();
// append data to query string
$request->fullUrlWithQuery(['type' => 'phone']);
```
### Request Method
```php
$method = $request->method();
// verify that the HTTP verb matches a given string
if ($request->isMethod('post')) {
//
}
```
### Client IP
```php
$ipAddress = $request->ip();
```
### Headers
```php
$value = $request->header('X-Header-Name');
$value = $request->header('X-Header-Name', 'default value');
// determine if the request contains a given header
if ($request->hasHeader('X-Header-Name')) {
//
}
// retrieve a bearer token from the Authorization header
$token = $request->bearerToken();
```
### Content Type
Return an array containing all the content types accepted by the request
```php
$contentTypes = $request->getAcceptableContentTypes();
```
Boolean check for content types are accepted by the request
```php
if ($request->accepts(['text/html', 'application/json'])) {
// ...
}
```
### Input {.row-span-4}
Retrieve all the incoming request's input data as an array
```php
$input = $request->all();
```
Retrieve all the incoming request's input data as a collection
```php
$input = $request->collect();
// retrieve subset as collection
$request->collect('users')->each(function ($user) {
// ...
});
```
See [Helpers](#helpers-cols-3)
Retrieve user input (also gets values from query string)
```php
$name = $request->input('name');
// with default value if none present
$name = $request->input('name', 'Sally');
```
Access array inputs
```php
$name = $request->input('products.0.name');
$names = $request->input('products.*.name');
```
Retrieve all the input values as an associative array:
```php
$input = $request->input();
```
Only retrieve values from the query string:
```php
$name = $request->query('name');
// with default value
$name = $request->query('name', 'Helen');
```
Retrieve all the query string values as an associative array:
```php
$query = $request->query();
```
#### Boolean Input Values
Helpful for checkbox inputs or other booleans.
Return `true` for `1`, `"1"`, `true`, `"true"`, `"on"`, and `"yes"`.
All other values will return `false`
```php
$archived = $request->boolean('archived');
```
### Dynamic Properties
Access inputs via properties.
If not found as an input, the route parameters will be checked.
```php
$name = $request->name;
```
### Retrieve Partial Input
```php
$input = $request->only(['username', 'password']);
$input = $request->only('username', 'password');
$input = $request->except(['credit_card']);
$input = $request->except('credit_card');
```
### Check Existence
Determine if value(s) present
```php
if ($request->has('name')) {
//
}
// check if ALL values are present
if ($request->has(['name', 'email'])) {
//
}
// if any values are present
if ($request->hasAny(['name', 'email'])) {
//
}
```
### Old Input
Retrieve input from the previous request
```php
$username = $request->old('username');
```
Or use the `old()` helper
```php
<input type="text" name="username" value="{{ old('username') }}">
```
See: [Helpers](#helpers-cols-3)
See: [Forms](#forms-cols-3)
### Uploaded Files
Retrieve uploaded file from request
```php
$file = $request->file('photo');
$file = $request->photo;
```
Get file path or extension
```php
$path = $request->photo->path();
$extension = $request->photo->extension();
```
Store uploaded file with a randomly generated filename
```php
// path where the file should be stored relative to
// the filesystem's configured root directory
$path = $request->photo->store('images');
// optional 2nd param to specify the filesystem disk
$path = $request->photo->store('images', 's3');
```
Store uploaded file and specify the name
```php
$path = $request->photo->storeAs('images', 'filename.jpg');
$path = $request->photo->storeAs('images', 'filename.jpg', 's3');
```
See More: [Laravel File Storage](https://laravel.com/docs/8.x/filesystem)
Views
---------------
### Intro
- [Laravel Docs - Views](https://laravel.com/docs/8.x/views)
```html
<!-- View stored in resources/views/greeting.blade.php -->
<html>
<body>
<h1>Hello, <?php echo $name; ?></h1>
</body>
</html>
```
Create a view by placing a file with the `.blade.php`
extension in the `resources/views` directory.
### Pass Data to Views
#### As an array
```php
return view('greetings', ['name' => 'Victoria']);
```
#### Using with()
```php
return view('greeting')
->with('name', 'Victoria')
->with('occupation', 'Astronaut');
```
Access each value using the data's keys
```html
<html>
<body>
<h1>Hello, {{ $name }}</h1>
<!-- Or -->
<h1>Hello, <?php echo $name; ?></h1>
</body>
</html>
```
### view helper
Return a view from a route with the `view()` helper
```php
Route::get('/', function () {
return view('greeting', ['name' => 'James']);
});
```
See: [View Routes](#view-routes) and [Helpers](#helpers)
### Subdirectories
```php
// resources/views/admin.profile.blade.php
return view('admin.profile');
```
Blade Templates
---------------
### Intro
- [Laravel Docs - Blade Templates](https://laravel.com/docs/8.x/blade)
Blade is the templating engine included in Laravel
that also allows you to use plain PHP.
### Views
Blade views are returned using the `view()` helper
```php
Route::get('/', function () {
return view('welcome', ['name' => 'Samantha']);
});
```
See: [Views](#view-helper)
### Comments
```html
{{-- This comment will not be present in the rendered HTML --}}
```
### Directives {.row-span-3}
#### if Statements
```php
@if (count($records) === 1)
I have one record!
@elseif (count($records) > 1)
I have multiple records!
@else
I don't have any records!
@endif
```
#### isset & empty
```php
@isset($records)
// $records is defined and is not null...
@endisset
@empty($records)
// $records is "empty"...
@endempty
```
#### Authentication
```php
@auth
// The user is authenticated...
@endauth
@guest
// The user is not authenticated...
@endguest
```
#### Loops
```html
@for ($i = 0; $i < 10; $i++)
The current value is {{ $i }}
@endfor
@foreach ($users as $user)
<p>This is user {{ $user->id }}</p>
@endforeach
@forelse ($users as $user)
<li>{{ $user->name }}</li>
@empty
<p>No users</p>
@endforelse
@while (true)
<p>I'm looping forever.</p>
@endwhile
```
Loop Iteration:
```php
@foreach ($users as $user)
@if ($loop->first)
This is the first iteration.
@endif
@if ($loop->last)
This is the last iteration.
@endif
<p>This is user {{ $user->id }}</p>
@endforeach
```
See more: [Laravel Loop Variable](https://laravel.com/docs/8.x/blade#the-loop-variable)
### Displaying Data
Blade's echo statements `{{ }}` are automatically sent through
PHP's `htmlspecialchars` function to prevent XSS attacks.
Display the contents of the name variable:
```html
Hello, {{ $name }}.
```
Display results of a PHP function:
```html
The current UNIX timestamp is {{ time() }}.
```
Display data without escaping with `htmlspecialchars`
```html
Hello, {!! $name !!}.
```
### Including Subviews
Include a Blade view from within another view.
All variables that are available to the parent view are also available to the included view
```html
<div>
<!-- resources/views/shared/errors/blade.php -->
@include('shared.errors')
<form>
<!-- Form Contents -->
</form>
</div>
```
### Raw PHP
Execute a block of plain PHP
```php
@php
$counter = 1;
@endphp
```
### Stacks
Blade allows you to push to named stacks which can be rendered in another view or layout.
Useful for javascript libraries required by child views
```html
<!-- Add to the stack -->
@push('scripts')
<script src="/example.js"></script>
@endpush
```
Render the stack
```html
<head>
<!-- Head Contents -->
@stack('scripts')
</head>
```
Prepend to the beginning of a stack
```php
@push('scripts')
This will be second...
@endpush
// Later...
@prepend('scripts')
This will be first...
@endprepend
```
Forms
---------------
### Intro
- [Laravel Docs - Forms](https://laravel.com/docs/8.x/blade#forms)
### CSRF Field
Include a hidden CSRF token field to validate the request
```html
<form method="POST" action="/profile">
@csrf
...
</form>
```
See: [CSRF Protection](#csrf-protection)
### Method Field
Since HTML forms can't make `PUT`, `PATCH`, or `DELETE` requests, you
will need to add a hidden `_method` field to spoof these HTTP verbs:
```html
<form action="/post/my-post" method="POST">
@method('PUT')
...
</form>
```
### Validation Errors
```html
<!-- /resources/views/post/create.blade.php -->
<label for="title">Post Title</label>
<input id="title" type="text" class="@error('title') is-invalid @enderror">
@error('title')
<div class="alert alert-danger">{{ $message }}</div>
@enderror
```
See: [Validation](#validation-cols-3)
### Repopulating Forms
When redirecting due to a validation error, request input is flashed to the session.
Retrieve the input from the previous request with the `old` method
```php
$title = $request->old('title');
```
Or the `old()` helper
```html
<input type="text" name="title" value="{{ old('title') }}">
```
Validation
---------------
### Intro
- [Laravel Docs - Validation](https://laravel.com/docs/8.x/validation)
If validation fails, a redirect response to the previous URL will be generated.
If the incoming request is an XHR request, a JSON response with the
validation error messages will be returned.
### Logic
```php
// in routes/web.php
Route::get('/post/create', [App\Http\Controllers\PostController::class, 'create']);
Route::post('/post', [App\Http\Controllers\PostController::class, 'store']);
// in app/Http/Controllers/PostController...
public function store(Request $request)
{
$validated = $request->validate([
// input name => validation rules
'title' => 'required|unique:posts|max:255',
'body' => 'required',
]);
// The blog post is valid...
}
```
### Rules {.row-span-5}
Can also be passed as an array
```php
$validatedData = $request->validate([
'title' => ['required', 'unique:posts', 'max:255'],
'body' => ['required'],
]);
```
#### after:date
Field must be a value after a given date.
```php
'start_date' => 'required|date|after:tomorrow'
```
Instead of a date string, you may specify another field to compare against the date
```php
'finish_date' => 'required|date|after:start_date'
```
See [before:date](#beforedate)
#### after_or_equal:date
Field must be a value after or equal to the given date.
See [after:date](#afterdate)
#### before:date
Field must be a value preceding the given date.
The name of another field may be supplied as the value of `date`.
See [after:date](#afterdate)
#### alpha_num
Field must be entirely alpha-numeric characters
#### boolean
Field must be able to be cast as a `boolean`.
Accepted input are `true`, `false`, `1`, `0`, `"1"`, and `"0"`
#### confirmed
Field must have a matching field of `{field}_confirmation`.
For example, if the field is password, a matching `password_confirmation` field must be present
#### current_password
Field must match the authenticated user's password.
#### date
Field must be a valid, non-relative date according to the `strtotime` PHP function.
#### email
Field must be formatted as an email address.
#### file
Field must be a successfully uploaded file.
See: [Uploaded Files](#uploaded-files)
#### max:value
Field must be less than or equal to a maximum value.
Strings, numerics, arrays, and files are evaluated like the [size](#sizevalue) rule.
#### min:value
Field must have a minimum value.
Strings, numerics, arrays, and files are evaluated like the [size](#sizevalue) rule.
#### mimetypes:text/plain,...
File must match one of the given MIME types:
```php
'video' => 'mimetypes:video/avi,video/mpeg,video/quicktime'
````
File's contents will be read and the framework will attempt to guess the
MIME type, regardless of the client's provided MIME type.
#### mimes:foo,bar,...
Field must have a MIME type corresponding to one of the listed extensions.
```php
'photo' => 'mimes:jpg,bmp,png'
````
File's contents will be read and the framework will attempt to guess the
MIME type, regardless of the client's provided MIME type.
[Full listing of MIME types & extensions](https://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types)
#### nullable
Field may be null.
#### numeric
Field must be numeric.
#### password
Field must match the authenticated user's password.
#### prohibited
Field must be empty or not present.
#### prohibited_if:anotherfield,value,...
Field must be empty or not present if the
_anotherfield_ field is equal to any value.
#### prohibited_unless:anotherfield,value,...
Field must be empty or not present unless the
_anotherfield_ field is equal to any value.
#### required
Field must be present in the input data and not empty.
A field is considered "empty" if one of the following conditions are true:
- The value is `null`.
- The value is an empty string.
- The value is an empty array or empty `Countable` object.
- The value is an uploaded file with no path.
#### required_with:foo,bar,...
Field must be present and not empty, only if any of the other
specified fields are present and not empty
#### size:value
Field must have a size matching the given value.
- For strings: number of characters
- For numeric data: integer value (must also have the `numeric` or `integer` rule).
- For arrays: count of the array
- For files: file size in kilobytes
```php
// Validate that a string is exactly 12 characters long...
'title' => 'size:12';
// Validate that a provided integer equals 10...
'seats' => 'integer|size:10';
// Validate that an array has exactly 5 elements...
'tags' => 'array|size:5';
// Validate that an uploaded file is exactly 512 kilobytes...
'image' => 'file|size:512';
```
#### unique:table,column
Field must not exist within the given database table
#### url
Field must be a valid URL
[See all available rules](https://laravel.com/docs/8.x/validation#available-validation-rules)
### Validate Passwords
Ensure passwords have an adequate level of complexity
```php
$validatedData = $request->validate([
'password' => ['required', 'confirmed', Password::min(8)],
]);
```
`Password` rule object allows you to easily customize the password complexity requirements
```php
// Require at least 8 characters...
Password::min(8)
// Require at least one letter...
Password::min(8)->letters()
// Require at least one uppercase and one lowercase letter...
Password::min(8)->mixedCase()
// Require at least one number...
Password::min(8)->numbers()
// Require at least one symbol...
Password::min(8)->symbols()
```
Ensure a password has not been compromised in a public password data breach leak
```php
Password::min(8)->uncompromised()
```
> _Uses the [k-Anonymity](https://en.wikipedia.org/wiki/K-anonymity) model via the [haveibeenpwned.com](https://haveibeenpwned.com) service without sacrificing the user's privacy or security_
Methods can be chained
```php
Password::min(8)
->letters()
->mixedCase()
->numbers()
->symbols()
->uncompromised()
```
### Display Validation Errors
```php
<!-- /resources/views/post/create.blade.php -->
<h1>Create Post</h1>
@if ($errors->any())
<div class="alert alert-danger">
<ul>
@foreach ($errors->all() as $error)
<li>{{ $error }}</li>
@endforeach
</ul>
</div>
@endif
<!-- Create Post Form -->
```
See: [Validation Errors](#validation-errors)
### Optional Fields
You will often need to mark your "optional" request fields as `nullable`
if you do not want the validator to consider `null` values as invalid
```php
// publish_at field may be either null or a valid date representation
$request->validate([
'title' => 'required|unique:posts|max:255',
'body' => 'required',
'publish_at' => 'nullable|date',
]);
```
### Validated Input
Retrieve the request data that underwent validation
```php
$validated = $request->validated();
```
Or with `safe()`, which returns an instance of `Illuminate\Support\ValidatedInput`
```php
$validated = $request->safe()->only(['name', 'email']);
$validated = $request->safe()->except(['name', 'email']);
$validated = $request->safe()->all();
```
#### Iterate
```php
foreach ($request->safe() as $key => $value) {
//
}
```
#### Access as an array
```php
$validated = $request->safe();
$email = $validated['email'];
```
Session
---------------
### Intro
- [Laravel Docs - Session](https://laravel.com/docs/8.x/session)
Laravel ships with a variety of session backends that are accessed through
a unified API. Memcached, Redis, and database support is included.
#### Configuration
Session configuration is in `config/session.php`.
By default, Laravel is configured to use the file session driver
### Check Isset / Exists
Returns `true` if the item is present and is not `null`:
```php
if ($request->session()->has('users')) {
//
}
```
Returns `true` if present, even if it's `null`:
```php
if ($request->session()->exists('users')) {
//
}
```
Returns `true` if the item is `null` or is not present:
```php
if ($request->session()->missing('users')) {
//
}
```
### Retrieving Data {.row-span-2}
#### Via Request
```php
// ...
class UserController extends Controller
{
public function show(Request $request, $id)
{
$value = $request->session()->get('key');
//
}
}
```
Pass a default value as the second argument to use
if the key does not exist
```php
$value = $request->session()->get('key', 'default');
// closure can be passed and executed as a default
$value = $request->session()->get('key', function () {
return 'default';
});
```
#### Via session helper
```php
Route::get('/home', function () {
// Retrieve a piece of data from the session...
$value = session('key');
// Specifying a default value...
$value = session('key', 'default');
// Store a piece of data in the session...
session(['key' => 'value']);
});
```
See: [Session Helper]()
#### All Session Data
```php
$data = $request->session()->all();
```
#### Retrieve and Delete
Retrieve and delete an item from the session
```php
$value = $request->session()->pull('key', 'default');
```
### Store Data
Via a request instance
```php
$request->session()->put('key', 'value');
```
Via the global "session" helper
```php
session(['key' => 'value']);
```
Push a new value onto a session value that is an array
```php
// array of team names
$request->session()->push('user.teams', 'developers');
```
Logging
---------------
### Configuration
Configuration options for logging behavior is in `config/logging.php`.
By default, Laravel will use the stack channel when logging messages, which aggregates multiple log channels into a single channel.
### Levels {.row-span-2}
All the log levels defined in the [RFC 5424 specification](https://tools.ietf.org/html/rfc5424) are available:
- emergency
- alert
- critical
- error
- warning
- notice
- info
- debug
### Log Facade {.row-span-2}
```php
use Illuminate\Support\Facades\Log;
Log::emergency($message);
Log::alert($message);
Log::critical($message);
Log::error($message);
Log::warning($message);
Log::notice($message);
Log::info($message);
Log::debug($message);
```
### Contextual Info
```php
use Illuminate\Support\Facades\Log;
Log::info('User failed to login.', ['id' => $user->id]);
```
Deployment
---------------
### Intro
- [Laravel Docs - Deployment](https://laravel.com/docs/8.x/deployment)
Ensure your web server directs all requests to your application's `public/index.php` file
### Optimization
#### Composer's autoloader map
```bash
composer install --optimize-autoloader --no-dev
```
#### Configuration Loading
Be sure that you are only calling the `env` function from within your configuration files.
Once the configuration has been cached, the `.env` file will not be loaded and all calls
to the `env` function for `.env` variables will return `null`
```bash
php artisan config:cache
```
#### Route Loading
```bash
php artisan route:cache
```
#### View Loading
```bash
php artisan view:cache
```
### Debug Mode
The debug option in your `config/app.php` determines how much information
about an error is actually displayed to the user.
By default, this option is set to the value of the `APP_DEBUG` environment
variable in your `.env` file.
In your production environment, this value should always be `false`.
If the `APP_DEBUG` variable is set to `true` in production, you risk exposing sensitive configuration values to end users.
Also see
-------
- [Laravel Docs](https://laravel.com/docs/8.x)
- [Laracasts](https://laracasts.com/)
- [Laravel API](https://laravel.com/api/8.x/)