PHP Case Sensitivity

PHP is considered partially case-sensitive. While language statements and functions are not case-sensitive, variable names are case-sensitive. For example, $variable and $VARIABLE would be treated as different entities.

Tags in PHP

PHP supports various tags for embedding PHP code within HTML or other documents:

• Standard Tags: <?php ?> – These are the most commonly used tags for PHP code.
• Short Tags: <? ?> and <?= $var ?> – Shorter alternatives to the standard tags. Note: Short tags are not always enabled in PHP configurations.
• Script Tags: <script language="php"></script> – An older way of embedding PHP code, not commonly used now.
• ASP Tags: <% %> – Similar to ASP style tags, supported for backward compatibility but not recommended for new code.

Variables in PHP

In PHP, variables are declared using the $ symbol. It is important to note the following about variables:

• Curlies: Variables can be enclosed in curly braces like ${a} or {$a}. This is especially useful when accessing array elements within a string.
• Quoting: Inside single quotes, variables are not directly interpolated. To include variables in strings, use double quotes instead.

Comments in PHP

Comments in PHP help in documenting code and are not executed by the PHP parser. PHP supports various types of comments:

// Single line comment using double slashes.

# Single line comment using hash.

/* Multi-line
   comment using slash-asterisk.

/**
* API Documentation Example.
*
* @param string $bar
*/

// Heredoc syntax for multi-line strings.

<<<EOT
... text
EOT;

// Nowdoc syntax for multi-line strings. Introduced in PHP 5.3.0.

<<<'EOT'
... text
EOT;

Function Overloading in PHP

PHP does not directly support function overloading. However, you can simulate function overloading using the __call__ magic method. This is possible because PHP functions can accept variable-length argument lists. To handle variable arguments, functions like func_num_args(), func_get_arg(), and func_get_args() can be used.

Default Parameters

PHP allows you to set default parameters for functions. These parameters are used when no argument is provided for that parameter during a function call.

Global Variables

The $GLOBALS array in PHP contains references to all variables available in the global scope. By using the global keyword, you can access global variables within a function by importing them into the local variable table.

Variable Variables

PHP supports variable variables, denoted by $$var. This feature enables you to dynamically create variable names and access their values.

Super Globals in PHP

PHP provides various superglobal arrays such as $GLOBALS, $_GET, $_POST, $_SESSION, $_COOKIE, $_FILES, $_REQUEST, $_SERVER, and $_ENV. These arrays are accessible from anywhere in your PHP scripts.

Passing Arguments by Reference

In PHP, when passing arguments by reference, you use the ampersand (&) operator. Similarly, you can return values by reference using the ampersand operator.

Anonymous Functions (Closures)

Anonymous functions, also known as closures, are functions without a specified name. They can be assigned to variables and passed as arguments to other functions. In PHP, anonymous functions yield objects of the closure class.

$area = function ($side) {
    return $side * $side;
};

echo $area(5);

Constants in PHP

Constants in PHP can be defined using the define() function. The syntax is define("constantname", value, true/false), where setting the third parameter to true makes the constant case-insensitive.

• To check if a constant is defined, you can use the defined("constantname") function.
• To retrieve the value of a constant stored in a variable or a function, you can use constant($var), where $var holds the constant name.

Error vs. Exception

In PHP, errors and exceptions play distinct roles in the handling of issues that may arise during script execution. Errors are predefined problems that occur when the script runs, while exceptions are objects specifically designed to represent and manage errors.

Types of Errors

• Compile Time Errors: These errors are identified during the compilation of the code. They cannot be caught and will lead to the termination of the script if not rectified promptly.
• Fatal Errors: Critical errors that abruptly halt the execution of the script and cannot be recovered from. These errors usually indicate severe issues in the code.
• Recoverable Errors: Errors that can be managed within the script by implementing appropriate error-handling mechanisms. These errors allow for recovery and continuation of script execution.
• Warnings: Warnings signal potential problems in the script but do not halt its execution. They serve as alerts for developers to investigate and address potential issues.
• Notices: Notices provide informational messages about non-critical problems in the script without affecting its execution. These messages are typically used for debugging and optimization purposes.

Error Reporting in PHP

Controlling how errors are handled and displayed is crucial in PHP development. The error reporting directive in PHP allows developers to manage error visibility and logging effectively. The settings display_errors and log_errors determine whether errors are displayed on the screen and logged to a file, respectively.

To suppress errors for a specific expression, developers can utilize the @ symbol, known as the error control operator.

For custom error handling, developers can define a custom error handler using set_error_handler("functionName") to treat errors as exceptions and implement personalized error management logic.

set_error_handler("customError");
function customError($errno, $errstr) {
    // Custom error handling logic
}

Exceptions in PHP

• Exception Class: In PHP, the Exception class serves as the foundation for exception handling. Developers have the flexibility to create custom exception classes by extending the base Exception class to address specific error scenarios.
• Throwing Exceptions: To trigger an exception within a script, developers use the throw keyword to raise the exception and interrupt the normal flow of execution.
• Exception Handling: PHP offers the capability to establish a catch-all function using set_exception_handler() to manage uncaught exceptions gracefully and provide a centralized approach to exception handling.

function handleUncaughtException($e) {
    echo $e->getMessage();
}

Introduction to Design Patterns

Design patterns are proven solutions to common software design problems that have been implemented and refined over time. They offer a structured approach to addressing recurring design challenges, enhancing code reusability, maintainability, and scalability. Design patterns can be applied in various programming paradigms, including procedural programming and Object-Oriented Programming (OOP).

Singleton Pattern

The Singleton Pattern ensures that a class has only one instance globally accessible across the application. It is useful when you want to control the instantiation of a class and restrict it to a single object. In PHP, the Singleton Pattern typically involves a private constructor to prevent direct instantiation and a static method to provide access to the single instance.

An example of applying the Singleton Pattern in PHP is in managing a database connection. By enforcing a single database connection instance, you can avoid unnecessary overhead and ensure data consistency throughout the application.

Factory Pattern

The Factory Pattern is a creational design pattern that delegates the responsibility of object creation to a separate factory class. This pattern enables the creation of objects without specifying their concrete classes, promoting flexibility and decoupling. By centralizing object creation logic, the Factory Pattern simplifies the process of adding new object types without modifying existing code.

For instance, a system handling data storage can utilize the Factory Pattern to instantiate different storage classes based on user preferences. By adhering to a common interface, such as a storage interface, the factory can create diverse storage objects like INI, DB, or XML without exposing the instantiation details to the client code.

Registry Pattern

The Registry Pattern serves as a global store for sharing objects and data across different components of an application. It acts as a centralized repository for resources, offering a convenient way to access and manage shared objects. By utilizing the Registry Pattern, developers can simplify resource handling and enhance the accessibility of commonly used objects.

In PHP, the Registry Pattern can be implemented to store instances of classes or configuration settings in a key-value store, facilitating easy retrieval and modification of shared resources throughout the application’s execution.

MVC (Model-View-Controller) Pattern

The MVC pattern is a widely adopted architectural pattern in web development for structuring applications into three interconnected components: Model, View, and Controller. The Model represents the application’s data and business logic, the View presents the data to the user, and the Controller manages user input and orchestrates interactions between the Model and View.

Active Record Pattern

The Active Record Pattern is an architectural pattern that links database records to objects in an object-oriented manner. It encapsulates database operations within the object itself, enabling developers to interact with the database using object-oriented methods rather than raw SQL queries. By integrating the Active Record Pattern, developers can streamline CRUD operations (Create, Read, Update, Delete) on database records, simplifying data manipulation and retrieval tasks.

By following the Active Record Pattern, each object instance corresponds to a row in the database table, allowing developers to manipulate data directly through the object’s methods, enhancing code readability and maintainability.

Array Construction

Arrays in PHP can be constructed using different methods:

• array() construct: This is a language construct to create an array in PHP.
• Array operator []: Using square brackets to define and initialize an array.

Array Printing

Printing arrays in PHP can be done using various functions:

• print_r(): This function is used to display human-readable information about a variable, especially useful for arrays.
• var_dump(): A debugging function that displays structured information about variables, including type and value.
• var_export(): Outputs or returns a parsable string representation of a variable, mainly used for debugging arrays.

Array Operations

Performing operations on arrays in PHP involves various functions and methods:

• array(key = value) and array[key]=value: Ways to define key-value pairs in an array in PHP.
• Merging arrays: Using the + operator to merge two arrays into a new array.
• extract($arr, EXTR_PREFIX_ALL): Imports variables into the current symbol table from an array.
• count($arr, 1): Counts the number of elements in an array recursively, with the second argument to count elements in sub-arrays.

Array Cursors

PHP provides array cursor functions for easy navigation and manipulation:

• reset(): Resets the internal array pointer to the first element of the array.
• end(): Moves the internal array pointer to the last element of the array.
• next(): Advances the array pointer to the next element and returns its value.
• prev(): Moves the array pointer to the previous element and returns its value.