PHP Interview Questions

Here are a few sample PHP interview questions and answers for software professionals who are aiming to opt for profiles like PHP Developer, Full Stack Web Developer, etc. Set your bar higher with our PHP interview questions that will give you the much-needed edge over your peers. Prepare yourself with the top interview questions on PHP and get ready to answer questions on traits, namespace, composer, etc. These PHP interview questions are answered by the experts and will be your best guide to surviving the trickiest PHP interviews.

  • 4.7 Rating
  • 20 Question(s)
  • 22 Mins of Read
  • 9852 Reader(s)

Intermediate

Namespaces are a way of encapsulating items. In the PHP world, namespaces are designed to solve two problems that authors of libraries and applications encounter when creating reusable code elements such as classes or functions:

  1.    Name collisions between code you create, and internal PHP classes/functions/constants or third-party classes/functions/constants.
  2.    Ability to alias (or shorten) Extra_Long_Names designed to alleviate the first problem, improving readability of source code.

PHP Namespaces provide a way in which to group related classes, interfaces, functions and constants.

In simple terms, think of a namespace as a person's surname. If there are two people named "James" you can use their surnames to tell them apart.

namespace MyProject;

function output() {
# Output HTML page
echo 'HTML!';
}
namespace RSSLibrary;
function output(){
#  Output RSS feed echo 'RSS!';
}

Later when we want to use the different functions, we'd use:

\MyProject\output();
\RSSLibrary\output();

Or we can declare that we're in one of the namespaces and then we can just call that namespace's output():

namespace MyProject;

output(); # Output HTML page
\RSSLibrary\output();

Composer is a tool for dependency management in PHP. It allows you to declare the libraries your project depends on and it will manage (install/update) them for you. It is a dependency manager

  1.        It enables you to declare the libraries you depend on.
  2.         Finds out which versions of which packages can and need to be installed, and installs them (meaning it downloads them into your project).

composer init - to launch a wizard

composer require - to add a dependency, also creates a composer.json to manage dependencies

composer.lock - this file ensures that everyone in the project uses the same version of the packages by not allowing newer versions to be downloaded

PSR Stands for PHP Standard Recommendations. These are some guidelines created by the community to bring a standard to projects/Libraries and have a common language which everyone can speak and understand.

  • Basic coding standard
  • Coding style. Guide
  • Logger interface
  • Autoloading standard
  • Caching interface
  • HTTP Message interface
  • Container interface
  • Hypermedia links
  • Http Handlers
  • Simple cache
  • HTTP Factories
  • HTTP CLIENT

Here are some steps you can follow to check the syntax of PHP. Ensure PHP CLI is installed on your machine. Browse to the relevant folder where the code is. Run the command php -l testfile.phpvia command line.

This will detect any syntax errors in the code and display on a terminal

PHP-FPM (FastCGI Process Manager) is an alternative PHP FastCGI implementation with some additional features useful for sites of any size, especially busier sites. These features include:

  • Adaptive process spawning (NEW!)
  • Basic statistics (ala Apache's mod_status) (NEW!)
  • Advanced process management with graceful stop/start
  • Ability to start workers with different uid/gid/chroot/environment and different php.ini (replaces safe_mode)
  • Stdout & stderr logging
  • Emergency restart in case of accidental opcode cache destruction
  • Accelerated upload support
  • Support for a "slowlog"
  • Enhancements to FastCGI, such as fastcgi_finish_request() - a special function to finish request & flush all data while continuing to do something time-consuming (video converting, stats processing, etc.)

Xdebug is an extension for PHPto assist with debugging and development. It contains a single step debuggerto use with IDEs; it upgrades PHP's var_dump() function; it adds stack tracesfor Notices, Warnings, Errors and Exceptions; it features functionality for recording every function call and variable assignmentto disk; it contains a profiler; and it provides code coveragefunctionality for use with PHPUnit.

Xhprof: Xhprof was created by Facebook and includes a basic UI for reviewing PHP profiler data. It aims to have a minimum impact on execution times and requires relatively little space to store a trace. Thus, you can run it live without a noticeable impact on users and without exhausting the memory.

In order to reduce RTT ( Round trip time ), websockets becomes handy if you are thinking about performance.

  1. WebSocket is a protocol for creating a fast two-way channel between a web browserand a server. WebSocket overcomes limitations with HTTP to allow for low latency communications between a user and a web service
  2. PHP supports WebSockets and the following projects help us use them in our projects:

    i.   https://socketo.me 

Web Servers themselves cannot understand and parse PHP files, the external programs do it for them. There are many ways how you can do this, both with its pros and cons. Various ways:

  1. Mod_php: means PHP, as an Apache module
  2. FastCGI: a PHP process is launched by Apache, and it is that PHP process that interprets PHP code -- not Apache itself
  3. PHP-FPM: PHP-FPM (FastCGI Process Manager) is an alternative PHP FastCGI implementation with some additional features useful for sites of any size, especially busier sites

Here are the use-cases for array_map, array_reduce and array_walk.

  1. Array_map: Applies the callback to the elements of the given arrays
  2. Array_reduce: Iteratively reduce the array to a single value using a callback function
  3. Array_walk: Apply a user supplied function to every member of an array
<?php
$originalarray1 = array(2.4, 2.6, 3.5);
$originalarray2 = array(2.4, 2.6, 3.5);
print_r(array_map('floor', $originalarray1)); // $originalarray1 stays the same
// changes $originalarray2
array_walk($originalarray2, function (&$v, $k) { $v = floor($v); }); print_r($originalarray2);
// this is a more proper use of array_walk
array_walk($originalarray1, function ($v, $k) { echo "$k => $v", "\n"; });
//  array_map accepts several arrays print_r(
array_map(function ($a, $b) { return $a * $b; }, $originalarray1, $originalarray2)
);
//  select only elements that are > 2.5
print_r(
array_filter($originalarray1, function ($a) { return $a > 2.5; })
);
?>
Array
(
[0]  => 2
[1]  => 2
[2]  => 3
)
Array
(
[0]  => 2
[1]  => 2
[2]  => 3
)
0 => 2.4
1 => 2.6
2 => 3.5
Array
(
[0]  => 4.8
[1]  => 5.2
[2]  => 10.5
)
Array
(
[1]  => 2.6
[2]  => 3.5
)

Advanced

Traits are a mechanism for code reuse in single inheritance languages such as PHP. A Trait is intended to reduce some limitations of single inheritance by enabling a developer to reuse sets of methods freely in several independent classes living in different class hierarchies.

The semantics of the combination of Traits and classes are defined in a way that reduces complexity and avoids the typical problems associated with multiple inheritance and Mixins.

A Trait is similar to a class, but only intended to group functionality in a fine-grained and consistent way. It is not possible to instantiate a Trait on its own. It is an addition to traditional inheritance and enables horizontal composition of behaviour; that is, the application of class members without requiring inheritance.

<?php
trait Hello
{
function sayHello() {
echo "Hello";
}
}
trait World
{
function sayWorld() {
echo "World";
}
}
class MyWorld
{
use Hello, World;
}
$world = new MyWorld();
echo $world->sayHello() . " " . $world->sayWorld(); //Hello World

An inherited member from a base class is overridden by a member inserted by a Trait. The precedence order is that members from the current class override Trait methods, which in turn override inherited methods. An inherited method from a base class is overridden by the method inserted into MyHelloWorld from the SayWorld Trait.

The behaviour is the same for the methods defined in the MyHelloWorld class. The precedence order is that methods from the current class override Trait methods, which in turn override methods from the base class.

trait A {
function calc($v) {
return $v+1;
}
}
class MyClass {
use A {
calc as protected traitcalc;
}
function calc($v) {
$v++;
return $this->traitcalc($v);
}
}

Performance is a very important aspect considered in any language at runtime. In order to improve the performance of the PHP runtime engine, OPcache can help in a significant way.

A. OPcache improves PHP performance by storing precompiled script bytecode in shared memory, thereby removing the need for PHP to load and parse scripts on each request.

B. OPcache is bundled with PHP 5.5 and higher. OPcache is more closely bound to PHP itself than other bytecode cache engines like APC.

C. The whole cache engine works in the background and is transparent to a visitor or a web developer. In order to check its status, you may use one of the two functions that provide such information: opcache_get_configuration() and opcache_get_status()

a) Event Loop is a concept from Javascript. In a single threaded execution, the code is waiting for the activity to get over before moving ahead. Event Loop helps us utilize the waiting period to execute code.

b) PHP supports Event loop. There are multiple libraries which help us use event loop in our project

  1. https://github.com/reactphp
  2. https://github.com/icicleio
  3. https://github.com/asyncphp/doorman

A resource is a special variable, holding a reference to an external resource. Resources are created and used by special functions. The following is a list of functions which create, use or destroy PHP resources. The function is_resource() can be used to determine if a variable is a resource and get_resource_type() will return the type of resource it is. http://php.net/manual/en/resource.php

Generators provide an easy way to implement simple iterators without the overhead or complexity of implementing a class that implements the Iterator interface. A generator allows you to write code that uses foreachto iterate over a set of data without needing to build an array in memory, which may cause you to exceed a memory limit, or require a considerable amount of processing time to generate. Instead, you can write a generator function, which is the same as a normal function, except that instead of returning once, a generator can yield as many times as it needs to in order to provide the values to be iterated over.

<?php
function nums() {
echo "The generator has startedn";
for ($i = 0; $i < 5; ++$i) {
yield $i;
echo "Yielded $in";
}
echo "The generator has endedn";
}
foreach (nums() as $v);

Promises becomes very important when it comes to asynchronous communication and it also provides effective ways to manage resources.

  1. A promise is an object that may produce a single value sometime time in the future: either a resolved value, or a reason that it’s not resolved (e.g., a network error occurred). A promise may be in one of 3 possible states: fulfilled, rejected, or pending. Promise users can attach callbacks to handle the fulfilled value or the reason for rejection.
  2. It started with JS but has been implemented in variety of technologies including PHP.
  3. Some libraries we can use to implement promises in PHP:
  4. https://github.com/guzzle/promises
  5. https://github.com/reactphp/promise

Here is the code snippet for reference.

<?php
$array = array (1, 3, 3, 8, 15); $my_val = 3;
$filtered_data = array_filter($array, function ($element) use ($my_val) { return ($element != $my_val); } ); print_r($filtered_data);
?>

a) The indexes used in an ArrayAccess object are not limited to strings and integers as they are for arrays: you can use any type for the index as long as you write your implementation to handle them. This fact is exploited by the SplObjectStorage class.

b) ArrayAccess Interface: Interface to provide accessing objects as arrays class obj implements ArrayAccess {

private $container = array();
public function __construct() {
$this->container = array(
"one" => 1,
"two" => 2,
"three" => 3,
);
}
public function offsetSet($offset, $value) {
if (is_null($offset)) {
$this->container[] = $value;
} else {
$this->container[$offset] = $value;
}
}
public function offsetExists($offset) {
return isset($this->container[$offset]);
}
public function offsetUnset($offset) {
unset($this->container[$offset]);
}
public function offsetGet($offset) {
return isset($this->container[$offset]) ? $this->container[$offset] : null;
}
}
$obj = new obj;
var_dump(isset($obj["two"]));
var_dump($obj["two"]);
unset($obj["two"]);
var_dump(isset($obj["two"]));
$obj["two"] = "A value";
var_dump($obj["two"]);
$obj[] = 'Append 1';
$obj[] = 'Append 2';
$obj[] = 'Append 3';
print_r($obj);
bool(true)
int(2)
bool(false)
string(7) "A value"
obj Object
(
[container:obj:private] => Array
(
[one] => 1
[three] => 3
[two] => A value
[0]  => Append 1
[1]  => Append 2
[2]  => Append 3
)
)

a) JsonSerializable Interface: Objects implementing JsonSerializable can customize their JSON representation when encoded with json_encode().

class Items implements \JsonSerializable
{
private $var; private $var1; private $var2;
public function __construct()
{
// ...
}
public function jsonSerialize()
{
$vars = get_object_vars($this);
return $vars;
}
}

b) __toString: The toString() method allows a class to decide how it will react when it is treated like as a string.

Sometime when we try to access session object we get the object class as __PHP_Incomplete_Class.
This happens when we try to initialize the session before loading the class definitions for the object we are trying to save into the session.

To say it in simple, if class definitions are not defined, PHP creates incomplete objects of the class __PHP_Incomplete_Class.

To avoid __php_incomplete_class object session error, every class definition must be included or defined before starting the session

Description

PHP is a widely-used, server-side scripting language. It is an acronym for ‘PHP: Hypertext Preprocessor’. It is used for developing Static or Dynamic Websites or Web applications. PHP scripts can be executed only on those servers which have PHP installed. Professionals can opt for fields like PHP Developer, Full Stack Web Developer, etc.

According to Indeed.com, the average salary for a PHP Developer is $89,418 per year in the United States.
Top companies around the globe use and integrate PHP, to name a few: Facebook, Slack, Lyft, Whatsapp, etc.

If you have finally found your dream job in PHP but worried about how to crack the PHP Interview and what could be the possible PHP Interview Questions, then you have landed yourself at the right place. The demand for PHP jobs is increasing day by day. People who are looking, searching or preparing for PHP jobs, have to face some questions in the interview. Keeping this in mind we have designed the most common PHP Interview Questions on  PHP to help you succeed in your interview.

If you are a fresher and are planning to build your career as a PHP developer or even an experienced professional looking who wished to acquire a higher position, then you must go through the following PHP interview questions and answers to increase your chances of getting a PHP job easily and quickly.

PHP interview questions and answers for freshers and experienced here start with some basic concepts of the subject. These PHP developer interview questions are framed by experts and we have taken care to help you with the correct answers for the questions.

Prepare well with these PHP technical interview questions and follow your dream career.

Read More
Levels