Laravel Interview Questions and Answers

Setup and customisation process is easy and fast as compared to others. Inbuilt Authentication System Supports multiple file systems Pre-loaded packages like Laravel Socialite, Laravel cashier, Laravel elixir, Passport, Laravel Scout Eloquent ORM (Object Relation Mapping) with PHP active record implementation Built in command line tool “Artisan” for creating a code skeleton ,database structure and build their migration

PHP artisan is the command line interface/tool included with Laravel. It provides a number of helpful commands that can help you while you build your application easily. Here are the list of some artisian commands: php artisan list php artisan help php artisan tinker php artisan make php artisan –versian php artisan make modal modal_name php artisan make controller controller_name

Laravel is a free, open-source PHP web framework, created by Taylor Otwell and intended for the development of web applications following the model–view–controller (MVC) architectural pattern.

Simple MVC that can be extended easily Clean and secure routing Powerful Eloquent ORM for database Migrations Third party plugins

Named routes allow referring to routes when generating redirects or Url’s more comfortably. You can specify named routes by chaining the name method onto the route definition:

Route::get('user/profile', function () {
  //
})->name('profile');

You can specify route names for controller actions:

Route::get('user/profile', 'UserController@showProfile')->name('profile');

Once you have assigned a name to your routes, you may use the route's name when generating URLs or redirects via the global route function:

// Generating URLs...
$url = route('profile');// Generating Redirects...
return redirect()->route('profile');

In Laravel reverse routing is generating URL’s based on route declarations.Reverse routing makes your application so much more flexible. For example the below route declaration tells Laravel to execute the action “login” in the users controller when the request’s URI is ‘login’. http://mysite.com/login

Route::get(‘login’, ‘users@login’);

Using reverse routing we can create a link to it and pass in any parameters that we have defined. Optional parameters, if not supplied, are removed from the generated link.

{{ HTML::link_to_action('users@login') }}

It will create a link like http://mysite.com/login in view.

Rollback one step. Natively.

php artisan migrate:rollback --step=1

Eloquent has a method for that (Laravel 4./5.);

Model::whereNotNull('sent_at')
Laravel 3:
Model::where_not_null('sent_at')

Aggregate function is a function where the values of multiple rows are grouped together as input on certain criteria to form a single value of more significant meaning or measurements such as a set, a bag or a list. Below is list of some Aggregates methods provided by Laravel query builder:

count()
$products = DB::table(‘products’)->count();
max()
$price = DB::table(‘orders’)->max(‘price’);
min()

$price = DB::table(‘orders’)->min(‘price’);
avg()
*$price = DB::table(‘orders’)->avg(‘price’);
sum()
$price = DB::table(‘orders’)->sum(‘price’);

A Closure is an anonymous function. Closures are often used as callback methods and can be used as a parameter in a function.

function handle(Closure $closure) {
  $closure('Hello World!');
}
handle(function($value){
  echo $value;
});

Vue is the default to spin up with a laravel project. It comes packaged with every fresh laravel project. As it has official support, you can be sure that it’ll be maintained for a long time with the project architectures in mind coupling Vue & Laravel. The whole Laravel community is biased to Vuejs which makes packages related to vue+laravel more available.

Laravel's events provide a simple observer implementation, allowing you to subscribe and listen for various events that occur in your application. The EventServiceProvider included with your Laravel application provides a convenient place to register all of your application's event listeners. The listen property contains an array of all events (keys) and their listeners (values).

To generate events and listeners add listeners and events to your EventServiceProvider and use the event:generate command. php artisan event:generate

Scopes allow you to easily re-use query logic in your models. To define a scope, simply prefix a model method with scope:

class User extends Model {
  public function scopePopular($query)
  {
    return $query->where('votes', '>', 100);
  }
public function scopeWomen($query)
{
  return $query->whereGender('W');
}
}
Usage:
$users = User::popular()->women()->orderBy('created_at')->get();

Sometimes you may wish to define a scope that accepts parameters. Dynamic scopes accept query parameters:

class User extends Model {
  public function scopeOfType($query, $type)
  {
    return $query->whereType($type);
  }
}
Usage:
$users = User::ofType('member')->get();

Local scopes allow you to define common sets of constraints that you may easily re-use throughout your application.

public function scopePopular($query)
{
  return $query->where('votes', '>', 100);
}

Consider:

$users = App\User::popular()->active()->orderBy('created_at')->get();

When accessing Eloquent relationships as properties, the relationship data is "lazy loaded". This means the relationship data is not actually loaded until you first access the property. However, Eloquent can "eager load" relationships at the time you query the parent model. Eager loading alleviates the N + 1 query problem when we have nested objects (like books -> author). We can use eager loading to reduce this operation to just 2 queries.

Laravel Passport is native OAuth 2 server for Laravel apps. It uses the League OAuth2 Server package as a dependency but provides a simple, easy-to-learn and easy-to-implement syntax. Passport exposes a JSON API for your frontend to consume to let you manage your clients and tokens. Out of the box, Passport comes with Vue components that show how you might want to interact with this API in your app. You could use these components and call it done, or you could write your own tool to interact with the API.

Migrations are like version control for your database, allowing your team to easily modify and share the application's database schema. Migrations are typically paired with Laravel's schema builder to easily build your application's database schema. To create a migration, use the make:migration Artisan command:

php artisan make:migration create_users_table The new migration will be placed in your database/migrations directory. Each migration file name contains a timestamp which allows Laravel to determine the order of the migrations.

Facades provide a "static" interface to classes that are available in the application's service container. Unlike traditional static method calls, facades may be mocked. We can mock the call to the static facade method by using the shouldReceive method, which will return an instance of a Mockery mock.

// actual code
$value = Cache::get('key');// testing
Cache::shouldReceive('get')
->once()
->with('key')
->andReturn('value');

Laravel queues provide a unified API across a variety of different queue backends, such as Beanstalk, Amazon SQS, Redis, or even a relational database. Queues allow you to defer/postpone the processing of a time consuming task until a later time. Laravel includes a queue worker that will process new jobs as they are pushed onto the queue. You may run the worker using the queue:work Artisan command.

Below are types of relationships supported by Laravel Eloquent ORM. One To One One To Many One To Many (Inverse) Many To Many Has Many Through Polymorphic Relations Many To Many Polymorphic Relations

Laravel's database query builder provides a convenient, fluent interface to creating and running database queries. It can be used to perform most database operations in your application and works on all supported database systems. The Laravel query builder uses PDO parameter binding to protect your application against SQL injection attacks. There is no need to clean strings being passed as bindings.

Some QB features: Chunking Aggregates Selects Raw Expressions Joins Unions Where Ordering, Grouping, Limit, & Offset

By default Laravel’s base controller class uses a ValidatesRequests trait which provides a convenient method to validate all incoming HTTP requests coming from client. You can also validate data in laravel by creating Form Request.

Middleware provide a convenient mechanism for filtering HTTP requests entering your application. For example, Laravel includes a middleware that verifies the user of your application is authenticated.

Middleware provide a convenient mechanism for filtering HTTP requests entering your application. For example, Laravel includes a middleware that verifies the user of your application is authenticated.

A migration class contains two methods: up and down . The up method is used to add new tables, columns, or indexes to your database, while the down method should reverse the operations performed by the up method.

Traits have been added to PHP for a very simple reason: PHP does not support multiple inheritance. Simply put, a class cannot extends more than on class at a time. This becomes laborious when you need functionality declared in two different classes that are used by other classes as well, and the result is that you would have to repeat code in order to get the job done without tangling yourself up in a mist of cobwebs. Enter traits. These allow us to declare a type of class that contains methods that can be reused. Better still, their methods can be directly injected into any class you use, and you can use multiple traits in the same class. Let's look at a simple Hello World example. trait SayHello

{
  private function hello()
  {
    return "Hello ";
  }
private function world()
{
  return "World";
}
}
trait Talk
{
  private function speak()
  {
    echo $this->hello() . $this->world();
  }
}
class HelloWorld
{
  use SayHello;
  use Talk;
  public function __construct()
  {
    $this->speak();
  }
}
$message = new HelloWorld();
// returns "Hello World";

Autoloaders define ways to automatically include PHP classes in your code without having to use statements like require and include. PSR-4 would allow for simpler folder structures, but would prevent us from knowing the exact path of a class just by looking at the fully qualified name. PSR-0 on the other hand is chaotic on the hard drive, but supports developers who are stuck in the past (the underscore-in-class-name users) and helps us discern the location of a class just by looking at its name.

The Laravel inversion of control container is a powerful tool for managing class dependencies. Dependency injection is a method of removing hard-coded class dependencies. Instead, the dependencies are injected at run- time, allowing for greater flexibility as dependency implementations may be swapped easily. The IoC-Container is a component that knows how instances are created and knows of all their underlying dependencies and how to resolve them.

Lumen is not designed to replace Laravel, rather, it is a more specialized (and stripped-down) framework designed for micro-services and APIs. It took away unneeded features for an API such as HTTP sessions and cookies, and also limited the number of configuration options. Out-of-the-box, Lumen sacrified the flexibility of Laravel for speed. However, you can add Laravel components to Lumen to extend it, so it can be used for more than just micro- services and API. However, if your goal is to extend Lumen to become a website, you might as well use Laravel instead. They also have different use cases. Lumen and Laravel are meant to work together. For APIs and services are frequently get called, use Lumen. For user-facing applications, use Laravel.

Service providers are the central place to configure your application. Your own application, as well as all of Laravel's core services are bootstrapped via service providers. Bootstrapping means registering things, including registering service container bindings, event listeners, middleware, and even routes.

If the service container is something that allows you to define bindings and inject dependencies, then the service provider is the place where it happens.

Laravel uses Blade Templating Engine. Blade is the simple, yet powerful templating engine provided with Laravel. Unlike other popular PHP templating engines, Blade does not restrict you from using plain PHP code in your views. In fact, all Blade views are compiled into plain PHP code and cached until they are modified, meaning Blade adds essentially zero overhead to your application. Blade view files use the .blade.php file extension and are typically stored in the resources/views directory.

The cursor method allows you to iterate through your database records using a cursor, which will only execute a single query. When processing large amounts of data, the cursor method may be used to greatly reduce your memory usage.

foreach (Product::where('name', 'bar')->cursor() as $flight) {
  //do some stuff
}

The Laravel service container is a tool for managing class dependencies and performing dependency injection.

Artisan is the name of the command-line interface included with Laravel. It provides a number of helpful commands for your use while developing your application for example:

php artisan serve

// To start Laravel project

Migrations are necessary because: Without migrations, database consistency when sharing an app is almost impossible, especially as more and more people collaborate on the web app. Your production database needs to be synced as well.

Migrations are like version control for your database, allowing your team to easily modify and share the application's database schema. To create a migration, use: php artisan make:migration create_users_table

Cashier - Laravel Cashier provides an expressive, fluent interface to Stripe's and Braintree's subscription billing services. Dusk - Laravel Dusk provides an expressive, easy-to-use browser automation and testing API. Envoy - Laravel Envoy provides a clean, minimal syntax for defining common tasks you run on your remote servers. Horizon - Horizon provides a dashboard and code-driven configuration for your Laravel powered Redis queues. Passport - provides a full OAuth2 server implementation for your Laravel application in a matter of minutes. Scout - Laravel Scout provides a simple, driver based solution for adding full-text search to your Eloquent models. Socialite - a simple, convenient way to authenticate with OAuth providers using Laravel Socialite.

The Eloquent ORM included with Laravel provides a beautiful, simple ActiveRecord implementation for working with your database. Each database table has a corresponding Model which is used to interact with that table. Models allow you to query for data in your tables, as well as insert new records into the table.

Facades provide a static interface to classes that are available in the application's service container. Laravel facades serve as static proxies to underlying classes in the service container, providing the benefit of a terse, expressive syntax while maintaining more testability and flexibility than traditional static methods. All of Laravel's facades are defined in the Illuminate\Support\Facades namespace. Consider:

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

Laravel Migrations are like version control for the database, allowing a team to easily modify and share the application’s database schema. Migrations are typically paired with Laravel’s schema builder to easily build the application’s database schema.

Laravel event provides a simple observer pattern implementation, that allow to subscribe and listen for events in the application. An event is an incident or occurrence detected and handled by the program. Below are some events examples in Laravel: A new user has registered A new comment is posted User login/logout New product is added.