PHP Interview Question & Answer

PHP stands for "Hypertext Preprocessor" a widely-used, open-source, server-side scripting language ideal for building dynamic websites, web applications, and mobile APIs.

It supports a wide range of databases, including:MySQL, PostgreSQL, Oracle, Sybase, Solid, Generic ODBC

PHP Originally developed by Rasmus Lerdorf in 1994, PHP has grown into a powerful tool for building interactive and data-driven websites.

A session is a way to store information (variables) across multiple pages.

Session data is stored on the server and stored on the user's browser.

Session is a temporary storage Data while close the browser then the session times out.

Session unique ID assigns to unique ID (PHPSESSID) of each session.

The Start a session session_start();

Set session variables: $_SESSION['username'] = 'john_doe';

Access session variables echo $_SESSION['username'];

Unset or destroy a session unset($_SESSION['username']); session_destroy();

A Cookies is store information client computer your web browser.

They store data about a user on the browser.

Session is a temporary storage Data while close the browser then the session times out.

Session Cookies: Temporary; deleted when you close your browser.

Persistent Cookies Stored on your device for a set time.

Setcookie setcookie(name, value, expire, path, domain, secure, httponly);

Both are used to include a file within another PHP script

include() function If the file is not found or fails to load, include() generates a warning (E_WARNING), but the script continues to execute.

require(): When the file is require cannot be found, it will produce a fatal error (E_COMPILE_ERROR) and stops the execution of the script.

PEAR stands for “PHP Extension and Application Repository”. PEAR is a framework and repository for all of the reusable PHP components.

A structured library of open-source code for PHP developers.

A command-line tool to install packages.

A standardized way to write and share PHP code.

Variablesare "containers" for storing information.

$ sign A variable starts with the $ sign, followed by the name of the variable.

Underscore variable A variable name must start with a letter or the underscore character.

Number variableA variable name cannot start with a number.

Alpha numericA variable name can only contain alpha-numeric characters and underscores (A-z, 0-9, and _ )

Case sensitiveVariable names are case-sensitive ($age and $AGE are two different variables)

Notices Notices are non-critical errors that can occur during the execution of the script. These are not visible to users.

Warnings: error are more critical than notices. Warnings don’t interrupt the script execution. By default, these are visible to the user. Example: include() a file that doesn’t exist..

Fatal: This is the most critical error type and Happens when PHP cannot continue execution. example: require() a non-existent file

ini_set('display_errors', 1):Purpose of display errors on the browser screen.

ini_set('display_startup_errors', 1): Purpose of PHP to display errors that occur during PHPs startup sequence.

error_reporting(E_ALL):Purpose of which types of errors should be reported, Report all types of errors display.

ini_set('display_errors', 0):Purpose of Disables error display , Do not show errors to users.

ini_set('log_errors', 1):When set to 1, Log errors to a file.

is_array() Checks if a variable is an array.

in_array():Checks if a value exists in an array.

array_search():Searches an array for a value and returns the key/index if found.

Composer is a dependency management tool for PHP.

It allows you to install, manage, and update external libraries (packages) that your project depends on.

Composer Update: update all dependencies to the newest version allosed by your composer.json

Download and install the latest allowed packages versions

Update the composer.lock file when you want to upgrade package to newer versions

When you want to refresh the package list after modifying composer.json and set the path

Composer install:Install dependencies listed in your composer.lock.

you clone a project pr deploy it to a server

Read composer.lock and install exact versions of package

if no composer.lock exist it all back to composer.json and create a composer.lock

Composer- dump-autoload:regenerate the autoload files.

You are added new classes, removed classes or changed

Namespaced - but didnot change composer.json

No package installation or update Happens, just refresh vendor- autoload.php

• Implemeting caching machanisms.

• Efficient algorithems and data structures.

• Optimizing database query.

• Removed unnessary join.

• Remove Un-nessary function.

• Minimizing database need of

• Some data store in localization store local

• Use a CDN (Content Delivery Network): Like Cloudflare or AWS CloudFront

• Use browser caching to store static files locally.

• Compress images: Use tools like TinyPNG or WebP format.

• Lazy load images and videos to reduce initial load time.

• Use responsive design (CSS media queries or frameworks like Bootstrap).

• Use indexing for faster queries and Use pagination or limit results for large data sets.

• Code Remove unused scripts and styles.

• Use HTTPS (SSL certificate) , Keep software, plugins, and libraries up-to-date, Sanitize and validate all user input.

• Website speed optimization: Reducing file sizes, optimizing images, enabling browser caching

• for Website optimization is check of using gtmetrix,PageSpeed Insights or https://pagespeed.web.dev/

__construct(): If you create a __construct() function, php will automatically call this function when you create an object from a class.

• class Mobile {
  public $name;
  public $color;
function __construct($name) {
  $this->name = $name;
}
function get_name() {
  return $this->name;
}
}
$iphone = new Mobile("iphone");
echo $iphone->get_name();


__destruct(): If you create a __destruct() function, PHP will automatically call this function at the end of the script.

• class Mobile {
  public $name;
  public $color;
function __construct($name) {
  $this->name = $name;
}
function __destruct() {
  echo "The Mobile is {$this->name}.";
}
function get_name() {
  return $this->name;
}
}
$iphone = new Mobile("iphone");
echo $iphone->get_name();


The header() function in PHP is used to send raw HTTP headers to the browser before any output is sent..

Syntax: header(string $header, bool $replace = true, int $response_code = 0);.

Redirecting a Page: header("Location: https://example.com"); exit;.

Setting Content-Type: header("Content-Type: application/json");

Force File Download:

• header("Content-Disposition: attachment; filename=\"file.pdf\"");
• header("Content-Type: application/pdf");
• readfile("file.pdf");

Custom Status Codes: header("HTTP/1.1 404 Not Found");

Cache Control:

• header("Cache-Control: no-cache, must-revalidate");
• header("Expires: Sat, 1 Jul 2000 05:00:00 GMT");

File access Control:

• header("Access-Control-Allow-Origin: *"); // allow frontend
• header("Access-Control-Allow-Methods: POST, GET, OPTIONS"); // Allow methods
• header("Access-Control-Allow-Headers: Content-Type"); // Allow headers (like Content-Type)
• header("Access-Control-Allow-Headers: Content-Type, Authorization");
• header("Access-Control-Allow-Credentials: true");

Dependency Injection (DI) is a design pattern used in PHP to pass dependencies (like objects or services) into a class or Constructor, rather than letting the class create them itself.

Simple Definition: Dependency Injection is a technique where an object receives other objects it depends on, instead of creating them internally.

Constructor Injection: Most common; dependencies passed via the constructor.

Setter Injection: Dependencies passed via public setter methods.

Interface Injection:Dependency passed via an interface method.

• class Database {
public function connect() {
  return "Connected to DB";
}
}
class UserService {
private $db;
// Dependency Injection via constructor public function __construct(Database $db) {
  $this->db = $db;
}
public function getUser() {
  return $this->db->connect();
}
}
// Inject dependency from outside
$db = new Database();
$userService = new UserService($db);
echo $userService->getUser()


PSR PHP Standard recommendation.

ites a set of coding standards and guidelines for php designed to promote consistency

PSP-1: basic coding standard defines basic rules like using php tags, properClass naming convestions getClassName()

PSR-2:Coding style guid, code formating rules like indentation, line lenght,spacing.

PSR-12: extended coding style guide -code formatting including whitespace, visibility and method declaration.

PSR-4:Autoloading standard - autoloading classes using namespaces , its widly used.

PSR-7:HTTP message interface- http request and responses.

PSR-11:container interface.

PSR-14:Event dispatches.

PSR-15:HTTP server request handles.

Class: Classes define the blueprint for creating objects.

Object: Objects are instance of classes an instance of a class containing real data and behavior.

Encapsulation:Encapsulation involves restricting access to certain class members to prevent direct modification from outside the class with the help of getters and setters.

Access Modifies:

• Public: Accessible from any where - inside or outside the class.
• Protected: Accessible within the class and by inheriting class or derived class.
• Private:Accessible only within the class itself.
• Getters:Allow you to retrieving the value of private properties.
• Setters:Allow you to modify the values of private properties sately.

• class user {   public $name; public function setName($newName) {   return $this->name = $newName; } public function getName() {   return $this->name; } } $user = new user(); echo $user->setName('codekredit'); echo $user->getName(); echo $user->name(); // error connot access private properties

Inheritance: a class can inherit properties and methods from another class.

Polymorphism: a methods can behave differently based on the object calling them .

Overloading and Overriding :

Overloading : Function overloading contains same function name but different argument passing.

PHP overloading not supports

Overloading in PHP refers to dynamically creating properties or methods at runtime using magic methods like:_get() __set(), __call() (for methods) ,__isset() / __unset()

Overriding : same properies overriding both parent and child classes should have same funciton and argument.

Abstract Class and Interface class :

A static class is a class that cannot be instantiated and can’t create objects.

Only contains static methods and variables.

PHP does not have a "static class" keyword, but you can make all methods static:

A Final Class cannot be extended any other class.

A Final method cannot be overridden by subclasses.

• S – Single Responsibility Principle (SRP)

  A class should have one responsibility and only one reason to change.

  Each class should do only one job.

  // ❌ Bad: One class handles both user data and email
class User {
  public function save() { /* Save user */ }
  public function sendEmail() { /* Send email */ }
}
// ✅ Good: Split responsibilities
class User {
  public function save() { /* Save user */ }
}
class EmailService {
  public function sendEmail(User $user) { /* Send email */ }
}

• O – Open/Closed Principle (OCP)

  A class should be open for extension, but closed for modification

  You should be able to extend a class's behavior without modifying it..

  // ❌ Bad: Need to change this class every time we add a new payment method
class Payment {
public function pay($type) {
if ($type == 'paypal') { /* PayPal logic */ }
if ($type == 'card') { /* Card logic */ }
}
}
// ✅ Good: Use inheritance to extend behavior
interface PaymentMethod {
public function pay();
} class PayPal implements PaymentMethod {
public function pay() { echo "Pay with PayPal"; }
} class CreditCard implements PaymentMethod {
public function pay() { echo "Pay with Card"; }
}
function makePayment(PaymentMethod $payment) {
$payment->pay();
}

• L – Liskov Substitution Principle (LSP)

  Objects of a subclass should be substitutable for objects of the superclass without altering correctness.

  Subtypes must be substitutable for their base types.

  Any child class should be usable in place of the parent class without breaking the app.

  class Bird {
public function fly() { echo "Flying"; }
}
class Ostrich extends Bird {
public function fly() { throw new Exception("I can't fly"); } // ❌ Violates LSP
}
//Fix by restructuring the hierarchy:
abstract class Bird { }
class FlyingBird extends Bird {
public function fly() { echo "Flying"; } //right
}
class Ostrich extends Bird { }

• I – Interface Segregation Principle (ISP)

  A client should not be forced to implement interfaces it does not use.

  Split large interfaces into smaller, more specific ones.

  // ❌ Bad: Animal interface forces all to implement fly()
interface Animal {
public function eat();
public function fly();
}
class Dog implements Animal {
public function eat() {
echo "Dog eating";
}
public function fly() {
}
// ❌ Dog can't fly
}
// ✅ Good: Separate interfaces
interface Animal {
public function eat();
}
interface Flyable {
public function fly();
}
class Dog implements Animal {
public function eat() { echo "Dog eating";
}
}
class Bird implements Animal, Flyable {
public function eat() {
echo "Bird eating";
}
public function fly() {
echo "Bird flying";
}
}

• D – Dependency Inversion Principle (DIP)

  Depend on abstractions, not on concretions.

  High-level modules should not depend on low-level modules. , but both should depend on abstractions Or interfaces.

  // ❌ Bad: Tightly coupled
class MySQL {
public function connect() {
/* MySQL connection */
}
}
class App {
private $db;
public function __construct() {
$this->db = new MySQL(); // tightly coupled
}
}
// ✅ Good: Use an interface
interface Database {
public function connect();
}
class MySQL implements Database {
public function connect() {
/* MySQL connection */
}
}
class MongoDB implements Database {
public function connect() {
/* MongoDB connection */
}
}
class App {
private $db;
public function __construct(Database $db) {
$this->db = $db;
}
}


MVVM stands for Model-View-ViewModel.

Model: The Model represents the data and business logic of the application.

View: The View is the user interface of the application. It is responsible for displaying the data that the Model provides.

Controller: The Controller acts as an intermediary between the Model and the View.

ViewModel: The ViewModel serves as the middle-man between the Model and the View.