Laravel

PHP artisan is a command based (CLI) tool in laravel, It provides a good number of commands that can help us to build an application faster. Artisan commands are available by default for all important operation like database seeding, migration, cache configuration to clearing cache, setting application namespace, event and key generation, queueing, running scheduled tasks, etc.

To check available artisan command list, we can use the command :

php artisan list

Some important Laravel artisan commands are:

• Php artisan help
• php artisan tinker
• php artisan make
• php artisan –versian
• php artisan migrate
• php artisan make:model model_name
• php artisan make:controller controller_name
• php artisan make:auth
• php artisan cache:clear
• php artisan db:seed
• php artisan app:name
• php artisan event:generate

To create a new (custom) php artisan command:

• php artisan make:command

Middleware provides a mechanism to filter HTTP request, entering your application. Basic middleware can be explained with authentication. Laravel includes middleware for authentication.  if a user is unauthenticated then we want to redirect to the login page and if it’s authenticated then we will allow proceeding further action. This can be easily done with middleware.

php artisan make:middleware middleware_name  is the artisan command to define a new middleware in your application. By default, all middleware will be stored in app/Http/Middleware directory.  To run middleware during every HTTP request to your application, you can list the middleware class in the $middleware property of your app/Http/Kernel.php class. To assign middleware to specific routes assign it in key-value pair at app/Http/Kernel.php class $routeMiddleware property.

Laravel route helps to build SEO friendly request URL. Most basic Laravel route accepts 2 parameters i.e. URI and closure.

Route::get('hello', function () {
   return 'Hello World';
});

All Laravel routes are defined in route file in routes directory. For web interface routes will be defined in routes/web.php whereas the routes in routes/api.php are stateless and are assigned the api middleware group.  

Available Route Methods

Route::get($uri, $callback);
Route::post($uri, $callback);
Route::put($uri, $callback);
Route::patch($uri, $callback);
Route::delete($uri, $callback);
Route::options($uri, $callback);

A staple in Laravel developer interview questions with answers, be prepared to answer this one using your hands-on experience. This is also one of the top interview questions to ask a Laravel.

Event is an occurrence that is to be handled by the program itself. Laravel events provide observer implementation in the application, that allows us to subscribe and listen to various events occurring in the application. Event classes are stored in app/Events directory whereas listeners classes will be stored in app/Listeners.

You can generate events manually as well as with artisan command. Artisan command to generate event is php artisan event:generate. Events and listeners should be listed in EventServiceProvider class. With artisan command, new event and listeners will be created whereas older one will be left untouched.

Laravel uses Blade templating engine. Blade is a powerful but simple templating engine of Laravel. Blade allows you to use plain php code into view and it compiles and cached view until it’s modified. Blade view files are stored in resources/views directory with extension .blade.php.

An example of blade file is :

<!-- /resources/views/alert.blade.php -->
<div class="alert alert-danger">
   {{ $slot }}
</div>

In the variable $slot we can assign any value which we want to inject to component. Component looks like:

@component('alert')
   <strong>Whoops!</strong> Something went wrong!
@endcomponent
@component is the blade directive here.

This, along with other Laravel basic interview questions for freshers, is a regular feature in Laravel interviews, be ready to tackle it with the approach mentioned.

First let's understand CSRF - It's cross-site request forgery attack. Cross-site forgeries are a type of malicious exploit where unauthorized commands can be executed on behalf of the authenticated user. Laravel generates a CSRF "token" automatically for each active user session. This token is used to verify that the authenticated user is the one actually making the requests to the application.

<form method="POST" action="/profile">
   @csrf
   ...
</form>

If you're defining an HTML form in your application you should include a hidden CSRF token field in the form so that middleware (CSRF Protection middleware) can validate the request. VerifyCsrfToken middleware is included in web middleware group. @csrf blade directive can be used to generate the token field.

If using JS driven application then you can attach your js HTTP library automatically attach the CSRF token with every HTTP request. resources/js/bootstrap.js is the default file which registers value of csrf-token meta tag with HTTP library.

To remove URIs from CSRF in verifyCsrfToken we can use $except property where can provide URLs which we want to exclude.

This is a common yet one of the most important questions for experienced Laravel Developers, don't miss this one.

Migrations are like version control for the database. With migration team can easily modify the database schema, migrations are paired with Laravel’s schema builder to easily build application’s db schema. With Laravel Schema facade creating and manipulating tables across the application is very easy. Artisan command to create migration schema is php artisan make:migration create_employeess_table. New migrations will be stored in database/migrations directory. Each migration will along with migration name contains the timestamp of the creation of file which helps Laravel to order migrations.

The --table and --create options may be used to indicate the name of the table and whether the migration will be creating a new table. These options pre-fill the generated migration stub file with the specified table:

• php artisan make:migration create_employees_table --create=employees
• php artisan make:migration add_departments_to_employee_table --table=employees

Laravel facades provide a "static" interface to classes that are available in the application's service container. All of Laravel's facades are defined in Illuminate\Support\Facades namespace. Facades are easy to use and don’t require injection so we can use many facades in one class. The benefit of using facade class is its expressive syntax, maintaining more testability and flexibility than traditional static methods of classes.

Access facade like:

use Illuminate\Support\Facades\Cache;
Route::get('/cache', function () {
   return Cache::get('key');
});

One of the most frequently posed advanced Laravel interview questions, be ready for this conceptual question.

Laravel service container is a great and powerful tool to manage dependencies and to perform dependency injection. So now the question comes what is dependency injection - In classes dependencies will be injected through either constructor or setter method.

<?php
namespace App\Http\Controllers;
use App\Employee;
use App\Repositories\EmployeeRepository;
use App\Http\Controllers\Controller;
class EmployeeController extends Controller
{
   /**
    * The employee repository implementation.
    *
    * @var EmployeeRepository
    */
   protected $employees;
   /**
    * Create a new controller instance.
    *
    * @param  EmployeeRepository  $employees
    * @return void
    */
   public function __construct(EmployeeRepository $employees)
   {
       $this->employees = $employees;
   }
   /**
    * Show the profile for the given employee.
    *
    * @param  int $id
    * @return Response
    */
   public function show($id)
   {
       $employee = $this->employees->find($id);
       return view('employee.profile', ['employee' => $employee]);
   }
}

Here EmployeeController needs to retrieve information of employee from a data source so we have injected a service that will provide information of the employee.

Before understanding eloquent let’s first understand ORM - Object Relational Mapping, it’s a programming technique for converting data between a relational database and object-oriented programming, we can say it an object-relational mapper as well.

Eloquent is an ORM used in Laravel. It provides simple Active record implementation working with the database. Each database table has their Model which used to interact with the table. Eloquent provides many types of relationships:

• One to One
• Many to one
• One to Many
• Many to Many
• Has one through
• Has many through

A staple in Laravel technical interview questions and answers, be prepared to answer this one using your hands-on experience.