Laravel Interview Questions and Answers

Laravel is a free and open-source PHP framework that is used to develop complex web applications. It supports the Model-View-Controller (MVC) design pattern. It is a very well documented, expressive, and easy to learn framework. The Laravel framework is also the most popular PHP framework among web developers in the year 2022.

Latest version of Laravel is 9.x

Validation is a way to protect your data while you insert or update the database. Laravel offers several ways to validate incoming data from your application. By default, Laravel’s base controller class uses a ValidatesRequests trait that provides a convenient way to validate all incoming HTTP requests. the customer. You can also validate data in Laravel by creating a form request.

Example

$validatedData = $request->validate([
 'name' => 'required|max:255',
 'username' => 'required|alpha_num',
 'age' => 'required|numeric',
]);

Composer is the package manager for the framework. Which help to add new packages on the Laravel Framework from the huge open source community. Suppose you want o install Laravel you can do this using composer

Example

composer create-project laravel/laravel your-project-name version

Following are some popular features

• Migration
• Database Seeding
• Eloquent of ORM
• Query Builder
• Blade Template Engine
• Unit Testing
• Lazy Collection

• Laravel Jetstream
• Models directory
• Model factory classes
• Migration squashing
• Time testing helpers
• Dynamic blade components
• Rate limiting improvements

• Cashier
• Envoy
• Passport
• Scout
• Socialite
• Horizon
• Telescope

The template engine used in Laravel is Blade. The blade provides the ability to use its moustache-like syntax with plain PHP, and is compiled into plain PHP and cached until other changes are made to the blade file. The blade file has .blade. php extension.

The following supported databases in laravel are:

• PostgreSQL
• SQL Server
• SQLite
• MySQL

Artisan is the command-line tool for Laravel which help to the developer build the application. You can enter the below command to get all the available commands:

PHP artisan list: Artisan command can help in creating the files using the make command. Some of the useful make commands are listed below:

php artisan make:controller - Make Controller file
php artisan make:model - Make a Model file
php artisan make:migration - Make Migration file
php artisan make:seeder - Make Seeder file
php artisan make:factory - Make Factory file
php artisan make:policy - Make Policy file
php artisan make:command - Make a new artisan command

Maintenance mode is used to set up a maintenance page for customers, and under the hood we can do software updates, fix bugs, etc. Laravel applications can be put into maintenance mode with the following command:

php artisan down

And can put the application again on live using the below command:

php artisan up

Below are the four default route files in the routes folder in Laravel:

• web.php – For registering web routes.
• api.php – For registering API routes.
• console.php – For registering closure-based console commands.
• channel.php – For registering all your event broadcasting channels that your application supports.

The following list shows the available router methods in Laravel:

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

Go to the project directory in the command prompt and run the following command:

php artisan --version
OR
php artisan -v

The following list shows the aggregate methods provided by the query builder:

• count()
• max()
• min()
• avg()
• sum()

Migration are used to create a database schema. In migration files, we store table create/update/delete query. Also each migration file is stored with its timestamp of creation to keep track of the order in which it was created.

In migration file the up() method runs when we run php artisan migrate and down() method runs when we run php artisan migrate:rollback.

If we rollback, it only rolls back the previously run migration.

If we want to undo all migrations, we can run ‘php artisan migrate:reset`.

If we want to rollback and run migrations, we can run PHP artisan migrate:refresh, and we can use PHP artisan migrate:fresh to drop the tables first and then run migrations from the start.

Seeders in Laravel are used to put data in the database tables automatically. After running migrations to create the tables, we can run php artisan db:seed to run the seeder to populate the database tables.

We can create a new Seeder using the below artisan command:

php artisan make:seeder [className]

Sample new seeder look like below. In which the run() method in the below code snippet will create 10 new users using the User factory

<?php

use App\Models\Auth\User;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Seeder;

class UserTableSeeder extends Seeder
{
    /**
     * Run the database seeds.
     */    public function run()
    {
        factory(User::class, 10)->create();
    }
}

Factories are a way to put values in fields of a particular model automatically. For example, to test when we add multiple fake records to the database, we can use factories to generate a class for each model and input data into the fields accordingly. Every new laravel application comes with database/factories/UserFactory.php which looks like below:

We can create a new factory using php artisan make:factory UserFactory --class=User

<?php

namespace Database\Factories;

use App\Models\User;
use Illuminate\Database\Eloquent\Factories\Factory;
use Illuminate\Support\Str;

class UserFactory extends Factory
{
   /**
    * The name of the factory's corresponding model.
    *
    * @var string
    */   protected $model = User::class;

   /**
    * Define the model's default state.
    *
    * @return array
    */   public function definition()
   {
       return [
           'name' => $this->faker->name,
           'email' => $this->faker->unique()->safeEmail,
           'email_verified_at' => now(),
           'password' => '$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi', // password
           'remember_token' => Str::random(10),
       ];
   }
}

Following some tools which are used to send emails in laravel

• Mailtrap
• Mailgun
• Mailchimp
• Mandrill
• Amazon Simple Email Service (SES)
• Swiftmailer
• Postmark

Soft Delete means when we delete any data from database. It helps to not delete data permanent but adding a timestamp of deletion, so we can restore the data with easily when we accidently delete the data

Laravel provides support for soft deleting using the Illuminate\Database\Eloquent\SoftDeletes trait.

When we open the newly created migration we’ll add the following lines to our up() function.

$table->string('name');
$table->softDeletes();

dd() is a helper function used to dump the contents of a variable to the browser and stop subsequent script execution. It means dump and die. It is used to dump the variable/object and then stop the script execution. You can also isolate this function in a reusable function file or class.

The Laravel event provides a simple implementation of observer patterns that you can use to subscribe to and listen to events in your application. An event is an incident or event that is recognized 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.

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:

Example

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

Relationships in Laravel are a way to define relations between different models in the applications. It is the same as relations in relational databases.

Different relationships available in Laravel are:

• One to One
• One to Many
• Many to Many
• Has One Through
• Has Many Through
• One to One (Polymorphic)
• One to Many (Polymorphic)
• Many to Many (Polymorphic)

Eloquent is the ORM which interact with the database using Model classes. Models allow you to query for data in tables, as well as insert new records into the table.

Example

DB::table('users')->get()
User::all()
User::where('name', '=', 'Eloquent')->get()

Throttling is a process of limiting the request rate from a given IP. This can also be used to prevent DDOS attacks. As a constraint, Laravel provides middleware that can be applied to routes and also added to the global list of middleware. run this middleware for each request.

Here’s how you can add it to a particular route:

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

This will enable the /user route to be accessed by a particular user from a particular IP only 60 times in a minute.

Facades are a way to register your class and its methods in Laravel Container so they are available in your whole application after getting resolved by Reflection.

The main benefit of using facades is we don’t have to remember long class names and also don’t need to require those classes in any other class for using them. It also gives more testability to the application.

Events are a way to subscribe to different events that occur in the application. We can make events to represent a particular event like user logged in, user logged out, user-created post, etc. After which we can listen to these events by making Listener classes and do some tasks like, user logged in then make an entry to audit logger of application.

Create new event with below command

php artisan make:event UserLoggedIn

Laravel logging is a way of recording information that happens within an application. Laravel provides different channels for logging, e.g. Files and Slack. Log messages can also be written to multiple channels at the same time.

We can configure the channel to be used for logging in to our environment file or in the config file at config/logging.php

Requests in Laravel are a way to interact with incoming HTTP requests along with sessions, cookies, and even files when sent with the request.

The class responsible for this is Illuminate\Http\Request.

As each request is sent down the Laravel route, it passes the controller method and the request object can be accessed within the method using dependency injection. We can do all kinds of things on request e.g. B. Validate or authorize requests, etc.

Route groups in Laravel are used when we need to group route attributes like middleware, prefixes, etc. We use route groups. It saves us a headache to include every attribute in every route.

Example

Route::middleware(['throttleMiddleware'])->group(function () {
    Route::get('/', function () {
        // Uses throttleMiddleware
    });

    Route::get('/user/profile', function () {
        // Uses throttleMiddleware
    });
});

For creating a resource route we can use the below command:

Route::resource('blogs', BlogController::class);

This will create routes for six actions index, create, store, show, edit, update and delete.

A collection in Laravel is a container for a set of data in Laravel. All responses from Eloquent ORM when we request data from the database are collections (arrays of records). Collections give us additional handy ways to easily work with data, such as: B. iterating over the data or performing some operations on it

While building the app we encountered a situation where a task was taking some time to process and our pages would load until the task was completed. Its job is to send an email when the user signs up. We can send emails to users as background tasks to keep our main thread responding at all times. Queues are a way to run such tasks in the background.

Laravel Service Container or IoC resolves all dependencies on all controllers. So we can show all the dependencies in the controller or constructor method. The dependency on the method is resolved and injected into the method, this resolved class injection is called dependency injection