Laravel

Question 1

Your own application, as well as all of Laravel’s core services are bootstrapped via

Answer 1

service providers

Question 2

the central place to configure your application is

Answer 2

Service providers

Question 3

All service providers extend the

Answer 3

Illuminate\Support\ServiceProvider

Question 4

Most service providers contain methods:

Answer 4

register and a boot

Question 5

Within the register method of service provider, you should only bind things into the

Answer 5

service container

Question 6

You should never attempt to register any event listeners, routes, or any other piece of functionality within the

Answer 6

register method

Question 7

Within any of your service provider methods, you always have access to the $app property which provides

Answer 7

access to the service container:

Question 8

This method is called after all other service providers have been registered, meaning you have access to all other services that have been registered by the framework

Answer 8

The Boot Method

Question 9

To defer the loading of a provider, implement the

Answer 9

\Illuminate\Contracts\Support\DeferrableProvider

Question 10

Facades provide a ? interface to classes that are available in the application’s service container

Answer 10

Static

Question 11

All of Laravel’s facades are defined in the

Answer 11

Illuminate\Support\Facades

Question 12

Using real times facades

Answer 12

You may treat all class in your system like it was facade
For example for App\Contracts\Publisher
Use
Facade\App\Contracts\Publisher

Question 13

You may modify the prefix and other route group options by modifying your

Answer 13

RouteServiceProvider class

Question 14

Sometimes you may need to register a route that responds to multiple HTTP verbs. You may do so using the match method. Or, you may even register a route that responds to all HTTP verbs using the any method

Answer 14

Route::match(['get', 'post'], '/', function () {
    //
});

Route::any('/', function () {
    //
});

Question 15

If you are defining a route that redirects to another URI, you may use the

Answer 15

Route::redirect

Question 16

By default, Route::redirect returns a

Answer 16

302

Question 17

You may use the ? method to return a 301 status code:

Answer 17

Route::permanentRedirect

Question 18

If your route only needs to return a view, you may use the

Answer 18

Route::view method

Route::view(‘/welcome’, ‘welcome’, [‘name’ => ‘Taylor’]);

Question 19

You may constrain the format of your route parameters using the WHAT method on a route instance

Answer 19

where

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]+']);

Question 20

If you would like a route parameter to always be constrained by a given regular expression, you may use the pattern method. You should define these patterns in the boot method of your RouteServiceProvider:

Answer 20

public function boot()
{
Route::pattern(‘id’, ‘[0-9]+’);

parent::boot(); }

Question 21

The Laravel routing component allows all characters except /. You must explicitly allow / to be part of your placeholder using a where condition regular expression:

Answer 21

Route::get(‘search/{search}’, function ($search) {
return $search;
})->where(‘search’, ‘.*’);

Question 22

If you would like to determine if the current request was routed to a given named route, you may use the named method on a Route instance. For example, you may check the current route name from a route middleware

Answer 22

public function handle($request, Closure $next)
{
    if ($request->route()->named('profile')) {
        //
    }

return $next($request); }

Question 23

Sub domain routing

Answer 23

Route::domain('{account}.myapp.com')->group(function () {
    Route::get('user/{id}', function ($account, $id) {
        //
    });
});

Question 24

To register an explicit binding, use the router’s model method to specify the class for a given parameter. You should define your explicit model bindings in the boot method of the RouteServiceProvider class:

Answer 24

public function boot()
{
parent::boot();

Route::model('user', App\User::class); }

Question 25

If you wish to use your own resolution logic, you may use the Route::bind method. The Closure you pass to the bind method will receive the value of the URI segment and should return the instance of the class that should be injected into the route:

/**
 * Bootstrap any application services.
 *
 * @return void
 */
public function boot()
{
    parent::boot();

    Route::bind('user', function ($value) {
        return App\User::where('name', $value)->first() ?? abort(404);
    });
}
Alternatively, you may override the resolveRouteBinding method on your Eloquent model. This method will receive the value of the URI segment and should return the instance of the class that should be injected into the route:

Answer 25

public function resolveRouteBinding($value)
{
return $this->where(‘name’, $value)->first() ?? abort(404);
}

Question 26

Using the Route::fallback method, you may

Answer 26

define a route that will be executed when no other route matches the incoming request.

Question 27

Laravel includes a middleware to rate limit access to routes within your application. To get started, assign the throttle middleware to a route or a group of routes. The throttle middleware accepts two parameters that determine the maximum number of requests that can be made in a given number of minutes. For example, let’s specify that an authenticated user may access the following group of routes 60 times per minute:

Answer 27

Route::middleware('auth:api', 'throttle:60,1')->group(function () {
    Route::get('/user', function () {
        //
    });
});

Question 28

You may specify a dynamic request maximum based on an attribute of the authenticated User model. For example, if your User model contains a rate_limit attribute, you may pass the name of the attribute to the throttle middleware so that it is used to calculate the maximum request count:

Answer 28

Route::middleware('auth:api', 'throttle:rate_limit,1')->group(function () {
    Route::get('/user', function () {
        //
    });
});

Question 29

You may specify different rate limits for guest and authenticated users. For example, you may specify a maximum of 10 requests per minute for guests 60 for authenticated users:

Answer 29

Route::middleware('throttle:10|60,1')->group(function () {
    //
});

Question 30

You may use the current, currentRouteName, and currentRouteAction methods on

Answer 30

the Route facade to access information about the route handling the incoming request

Question 31

To pass the request deeper into the application (allowing the middleware to “pass”),

Answer 31

call the $next callback with the $request.

Question 32

If you want a middleware to run during every HTTP request to your application,

Answer 32

list the middleware class in the $middleware property of your app/Http/Kernel.php class.

Question 33

When assigning middleware, you may also pass

Answer 33

the fully qualified class name
Route::get('admin/profile', function () {
    //
})->middleware(CheckAge::class);

Question 34

Rarely, you may need your middleware to execute in a specific order but not have control over their order when they are assigned to the route. In this case, you may specify your middleware priority using the

Answer 34

$middlewarePriority property of your app/Http/Kernel.php file

Question 35

Additional middleware parameters will be passed to the middleware after the

Answer 35

$next argument:

Question 36

Middleware parameters may be specified when defining the route by separating the middleware name and parameters with a

Answer 36

:

Question 37

Sometimes a middleware may need to do some work after the HTTP response has been sent to the browser. For example, the “session” middleware included with Laravel writes the session data to storage after the response has been sent to the browser. If you define a WHAT method on your middleware and your web server is using FastCGI, the WHAT method will automatically be called after the response is sent to the browse

Answer 37

terminate

Question 38

exclude the routes by adding their URIs to the $except property of the VerifyCsrfToken middleware:

Question 39

You may generate an invokable controller by using the

Answer 39

–invokable option of the make:controller artisan command

Question 40

Controllers also allow you to register middleware using a Closure. This provides a convenient way to define a middleware for a single controller without defining an entire middleware class:

Answer 40

$this->middleware(function ($request, $next) {
    // ...

return $next($request); });

Question 41

You may register many resource controllers at once by passing an array to the resources method:

Answer 41

Route::resources([
‘photos’ => ‘PhotoController’,
‘posts’ => ‘PostController’
]);

Question 42

When declaring a resource route, you may specify a subset of actions the controller should handle instead of the full set of default actions:

Answer 42

Route::resource(‘photos’, ‘PhotoController’)->only([
‘index’, ‘show’
]);

Route::resource(‘photos’, ‘PhotoController’)->except([
‘create’, ‘store’, ‘update’, ‘destroy’
]);

Question 43

By default, all resource controller actions have a route name; however, you can override these names by passing a names array with your options:

Answer 43

Route::resource(‘photos’, ‘PhotoController’)->names([
‘create’ => ‘photos.build’
]);

Question 44

By default, Route::resource will create resource URIs using English verbs. If you need to localize the create and edit action verbs, you may use the Route::resourceVerbs method. This may be done in the boot method of your AppServiceProvider:

Answer 44

use Illuminate\Support\Facades\Route;

/**
 * Bootstrap any application services.
 *
 * @return void
 */
public function boot()
{
    Route::resourceVerbs([
        'create' => 'crear',
        'edit' => 'editar',
    ]);
}

Question 45

If your application is exclusively using controller based routes, you should take advantage of Laravel’s route cache. Using the route cache will drastically decrease the amount of time it takes to register all of your application’s routes. In some cases, your route registration may even be up to 100x faster. To generate a route cache, just execute the route:cache Artisan command:

Answer 45

php artisan route:cache

Question 46

You may use the route:clear command to clear the route cache:

Answer 46

php artisan route:clear