PHP Fundamentals Programming Guide

PHP (Hypertext Preprocessor) is a versatile server-side scripting language that powers millions of websites and web applications worldwide. This guide is designed for beginners who want to learn PHP from the ground up. Whether you’re a complete programming novice or coming from another language, this guide will help you master PHP fundamentals.

Prerequisites

Basic understanding of HTML
Familiarity with web concepts
Text editor or IDE
Web server (will be covered in setup)

Setting Up PHP Environment

System Requirements

Minimum 256MB RAM (512MB recommended)
1GB free disk space
Web server software (Apache/Nginx)
Modern operating system (Windows/Linux/macOS)

Installation Process

Windows Installation

# Using XAMPP (Recommended for beginners)
1. Download XAMPP from apache friends website
2. Run installer
3. Select components (Apache, MySQL, PHP)
4. Choose installation directory
5. Complete installation

XAMPP is a complete package that bundles Apache, MySQL, PHP, and Perl together. This installation approach is recommended for beginners because it automatically configures these components to work together without requiring manual setup. After installation, you’ll have a fully functional local web server environment for PHP development.

Linux Installation

# Ubuntu/Debian
sudo apt-get update
sudo apt-get install php php-mysql php-fpm

This command updates your package repositories and installs PHP along with necessary extensions. The php-mysql package allows PHP to connect with MySQL databases, while php-fpm (FastCGI Process Manager) is needed when using PHP with web servers like Nginx. The sudo command executes these operations with administrator privileges.

macOS Installation

# Using Homebrew
brew install php

Homebrew is a popular package manager for macOS. This command installs the latest stable version of PHP. Before running this command, you need to have Homebrew installed on your system. This approach is simpler than manual installation and automatically adds PHP to your system path.

Server Integration

This section guides you through installing and configuring popular web servers to work with PHP on Linux systems.

Apache Installation and Configuration

# Ubuntu/Debian
sudo apt-get update
sudo apt-get install apache2
sudo systemctl start apache2
sudo systemctl enable apache2

The commands above install and configure Apache on Debian-based Linux distributions:

apt-get update refreshes the package repository
apt-get install apache2 installs the Apache web server
systemctl start apache2 starts the Apache service immediately
systemctl enable apache2 configures Apache to start automatically at boot time

After installation, Apache serves files from /var/www/html/ by default. To check if Apache is running, open a browser and navigate to http://localhost or your server’s IP address.

Apache PHP Integration

# Install PHP module for Apache
sudo apt-get install libapache2-mod-php

# Enable PHP module
sudo a2enmod php8.1  # Replace with your PHP version number

# Restart Apache
sudo systemctl restart apache2

The PHP module for Apache allows it to process PHP files directly. After installation, you need to edit Apache’s configuration to handle PHP files:

# /etc/apache2/apache2.conf or /etc/apache2/sites-available/000-default.conf
<FilesMatch \.php$>
    SetHandler application/x-httpd-php
</FilesMatch>

# Set index.php as directory index
<IfModule dir_module>
    DirectoryIndex index.php index.html
</IfModule>

This configuration tells Apache to:

Process all files with .php extension using the PHP handler
Look for index.php first when accessing a directory (before index.html)

Nginx Installation and Configuration

# Ubuntu/Debian
sudo apt-get update
sudo apt-get install nginx
sudo systemctl start nginx
sudo systemctl enable nginx

These commands install and configure Nginx web server:

apt-get install nginx installs the Nginx package
systemctl commands start the server and enable it at system startup

After installation, Nginx serves files from /var/www/html/ by default. To verify the installation, access http://localhost in your browser.

Nginx PHP Integration

Unlike Apache, Nginx doesn’t process PHP files directly. Instead, it forwards PHP requests to a separate PHP-FPM process:

# Install PHP-FPM
sudo apt-get install php-fpm

# Start and enable PHP-FPM
sudo systemctl start php8.1-fpm  # Replace with your PHP version
sudo systemctl enable php8.1-fpm

Configure Nginx to work with PHP-FPM by editing your server block configuration:

# /etc/nginx/sites-available/default
server {
    listen 80;
    server_name example.com www.example.com;
    root /var/www/html;
    
    index index.php index.html index.htm;
    
    location / {
        try_files $uri $uri/ =404;
    }
    
    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;  # Adjust PHP version
    }
    
    location ~ /\.ht {
        deny all;
    }
}

This configuration:

Sets the document root to /var/www/html
Configures index.php as the primary directory index
Passes all .php files to PHP-FPM using a Unix socket
Blocks access to .htaccess files for security

After making changes to the configuration, restart Nginx:

sudo systemctl restart nginx

Verifying PHP Integration

To test if PHP is working correctly with your web server:

Create a test file in your web root directory:
echo '<?php phpinfo(); ?>' | sudo tee /var/www/html/info.php
Open a browser and navigate to http://localhost/info.php
If properly configured, you’ll see the PHP information page showing details about your PHP installation and enabled modules.
For security, remove this file after testing:
sudo rm /var/www/html/info.php

Proper server integration ensures your PHP applications run efficiently and securely. Select the web server that best suits your project requirements—Apache is often easier to configure for beginners, while Nginx typically offers better performance for high-traffic websites.

The phpinfo() function displays comprehensive information about your PHP installation, including version, enabled modules, configuration settings, and environment variables. Creating this file and accessing it through your web browser is the quickest way to verify that PHP is working correctly on your server. You should delete this file after testing, as it reveals sensitive server information.

PHP Basics

Syntax Fundamentals

PHP Tags

<?php
// Your PHP code here
?>

PHP code must be enclosed within PHP tags to distinguish it from HTML or other content. The opening <?php tag tells the server to start interpreting the following code as PHP. The closing ?> tag returns to normal HTML mode. For files containing only PHP code, it’s recommended to omit the closing tag to prevent accidental whitespace output.

Comments

// Single line comment
# Alternative single line
/* Multi-line
   comment */

Comments are ignored by the PHP interpreter and used to document code. Single-line comments start with either // or # and continue until the end of the line. Multi-line comments begin with /* and end with */, allowing you to span comments across multiple lines. Well-commented code is easier to understand and maintain.

Statement Termination

$name = "John"; // Semicolon required
echo $name;     // Each statement ends with semicolon

In PHP, statements must end with a semicolon (;). This example shows two statements: first assigning the string “John” to the variable $name, and then outputting that variable using echo. Forgetting semicolons is a common source of syntax errors for beginners. The only exception is before a closing PHP tag or at the end of a file.

Variables and Data Types

Variable Declaration

$string = "Hello";    // String
$integer = 42;        // Integer
$float = 3.14;        // Float
$boolean = true;      // Boolean
$array = [1, 2, 3];   // Array

PHP variables are prefixed with a dollar sign ($) and are dynamically typed. This means you don’t need to declare the data type explicitly. This example shows the five most common data types: strings (text), integers (whole numbers), floats (decimal numbers), booleans (true/false values), and arrays (collections of values). Variable names are case-sensitive and must start with a letter or underscore.

Type Casting

$str = "123";
$num = (int)$str;    // Type casting to integer

Type casting allows you to convert a variable from one type to another. In this example, the string “123” is converted to the integer 123 using the (int) cast operator. PHP provides cast operators for all basic types: (int), (float), (string), (array), (object), (bool). Type casting is useful when you need to ensure a variable has a specific data type for calculations or comparisons.

Operators

Arithmetic Operators

$a = 10;
$b = 5;
$sum = $a + $b;      // Addition
$diff = $a - $b;     // Subtraction
$product = $a * $b;  // Multiplication
$quotient = $a / $b; // Division

This code demonstrates PHP’s basic arithmetic operators. The + operator adds two values, - subtracts, * multiplies, and / divides. After executing this code, $sum will be 15, $diff will be 5, $product will be 50, and $quotient will be 2. PHP also supports other arithmetic operators like % (modulo) for remainder calculations and ** (exponentiation) for raising to powers.

Control Structures

Conditional Statements

If/Else Statements

if ($age >= 18) {
    echo "Adult";
} elseif ($age >= 13) {
    echo "Teenager";
} else {
    echo "Child";
}

This code determines a person’s age category. It first checks if the age is 18 or older (using the >= comparison operator); if true, it outputs “Adult”. If that condition is false, it checks if the age is at least 13 (using elseif); if true, it outputs “Teenager”. If both conditions are false, the else block executes and outputs “Child”. Conditional statements like this let your code make decisions based on different conditions.

Switch/Case

switch ($fruit) {
    case "apple":
        echo "Selected apple";
        break;
    case "banana":
        echo "Selected banana";
        break;
    default:
        echo "Unknown fruit";
}

The switch statement provides a cleaner way to check a variable against multiple possible values. In this example, if $fruit equals “apple”, it outputs “Selected apple”. If it equals “banana”, it outputs “Selected banana”. The break statement prevents “fall-through” to the next case. If $fruit doesn’t match any case, the default block executes, outputting “Unknown fruit”. Switch statements are more readable than multiple if-else statements when comparing a single variable against many values.

Loops

For Loops

for ($i = 0; $i < 5; $i++) {
    echo $i;
}

The for loop executes code a specific number of times. It has three parts: initialization ($i = 0), condition ($i < 5), and iteration ($i++). This loop outputs the numbers 0 through 4. First, it sets $i to 0; then, before each iteration, it checks if $i is less than 5; after each iteration, it increments $i by 1 using the ++ operator. For loops are ideal when you know exactly how many iterations you need.

While Loops

$i = 0;
while ($i < 5) {
    echo $i++;
}

The while loop repeats code as long as its condition remains true. In this example, we initialize $i to 0 before the loop, then check if $i is less than 5 before each iteration. Inside the loop, we output $i and then increment it using the post-increment operator ($i++), which returns the value before incrementing. This loop also outputs 0 through 4. While loops are useful when you don’t know in advance how many iterations you’ll need.

Foreach Loops

$colors = ["red", "green", "blue"];
foreach ($colors as $color) {
    echo $color;
}

The foreach loop is designed specifically for iterating over arrays and objects. This code loops through each element of the $colors array, temporarily assigning each value to the $color variable, and then outputs it. This would display “redgreenblue”. The foreach loop automatically handles the iteration details, making it the most convenient way to process all elements in an array or object, especially when you don’t need to know the index or key.

Functions and Methods

Function Basics

function greet($name) {
    return "Hello, $name!";
}

echo greet("John"); // Outputs: Hello, John!

This code defines a function named greet that takes a single parameter $name. When called, it returns a greeting string that includes the provided name. The return keyword specifies what value the function should output when called. In the example, we call the function with the argument “John” and echo the result, which produces “Hello, John!”. Functions allow you to reuse code and organize your program into logical, self-contained units. Note that there was a typo in the original code (missing comma after “Hello”), which has been fixed.

Variable Scope

$global_var = "I'm global";

function testScope() {
    global $global_var;    // Accessing global variable
    $local_var = "I'm local";
    
    echo $global_var;      // Accessible
    echo $local_var;       // Only accessible within function
}

This demonstrates PHP’s variable scoping rules. Variables declared outside functions are “global” and not directly accessible inside functions. To access a global variable inside a function, you must use the global keyword as shown with $global_var. The variable $local_var is created inside the function and exists only within that function’s scope. After the function finishes executing, $local_var is destroyed, while $global_var continues to exist. Understanding scope is crucial for managing variables in larger applications.

Built-in Functions

String Functions

$str = "Hello World";
strlen($str);          // String length
strtoupper($str);      // Convert to uppercase
str_replace("World", "PHP", $str); // Replace text

PHP provides many built-in functions for string manipulation:

strlen($str) returns the length of the string (11 in this case)
strtoupper($str) converts the entire string to uppercase, returning “HELLO WORLD”
str_replace("World", "PHP", $str) replaces all occurrences of “World” with “PHP”, returning “Hello PHP”

Note that these functions don’t modify the original string; they return a new string with the requested changes. To save the modified string, you would need to assign the result to a variable, like $new_str = strtoupper($str).

Array Functions

$arr = [1, 2, 3];
array_push($arr, 4);   // Add element
array_pop($arr);       // Remove last element
count($arr);           // Array length

This code demonstrates common array manipulation functions:

array_push($arr, 4) adds the value 4 to the end of the array, modifying $arr to [1, 2, 3, 4]
array_pop($arr) removes and returns the last element of the array, changing $arr to [1, 2, 3]
count($arr) returns the number of elements in the array (3 in this case)

Unlike string functions, many array functions directly modify the original array. PHP offers dozens of specialized array functions for sorting, filtering, mapping, and other operations, making array manipulation very powerful.

Working with Data

Arrays

Indexed Arrays

$fruits = ["apple", "banana", "orange"];
echo $fruits[0]; // Access first element

This creates an indexed array called $fruits containing three elements. In PHP, array indices start at 0, so $fruits[0] refers to the first element (“apple”), $fruits[1] to the second element (“banana”), and so on. The echo $fruits[0] statement outputs “apple” to the browser or console. Indexed arrays are useful when the order of elements matters and you want to access them by their numerical position.

Associative Arrays

$person = [
    "name" => "John",
    "age" => 25,
    "city" => "New York"
];
echo $person["name"];

Associative arrays use named keys instead of numeric indices. This example creates an array storing information about a person. Each value is associated with a specific key using the => syntax. The statement echo $person["name"] outputs “John” by accessing the value associated with the “name” key. Associative arrays are ideal for representing structured data where you want to access values by meaningful names rather than numeric positions.

Form Handling

// Processing POST request
if ($_SERVER["REQUEST_METHOD"] == "POST") {
    $username = filter_input(INPUT_POST, 'username', FILTER_SANITIZE_STRING);
    $email = filter_input(INPUT_POST, 'email', FILTER_VALIDATE_EMAIL);
}

This code safely processes form data submitted via the POST method. It first checks if the current request is indeed a POST request using the superglobal $_SERVER array. If true, it processes two form fields:

$username is filtered using FILTER_SANITIZE_STRING, which removes potentially dangerous characters
$email is validated using FILTER_VALIDATE_EMAIL, which returns the email if valid or false otherwise

The filter_input() function is recommended over directly accessing $_POST as it provides built-in sanitization and validation. This approach helps prevent common security issues like cross-site scripting (XSS) attacks.

Database Integration

PDO Connection

try {
    $pdo = new PDO("mysql:host=localhost;dbname=mydb", "username", "password");
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch(PDOException $e) {
    echo "Connection failed: " . $e->getMessage();
}

This code establishes a secure connection to a MySQL database using PHP’s PDO (PHP Data Objects) extension. The process is wrapped in a try-catch block to handle potential connection errors gracefully.

In the try block:

A new PDO object is created with a connection string specifying the database type (mysql), host, database name, username, and password
Error reporting is set to throw exceptions with setAttribute, making errors easier to catch and handle

If the connection fails, the catch block catches the PDOException and displays a user-friendly error message. PDO is preferred over older methods like mysqli because it supports multiple database types and offers better security features like prepared statements.

CRUD Operations

// Insert
$stmt = $pdo->prepare("INSERT INTO users (name, email) VALUES (?, ?)");
$stmt->execute([$name, $email]);

// Select
$stmt = $pdo->query("SELECT * FROM users");
$users = $stmt->fetchAll();

This demonstrates basic Create and Read operations from CRUD:

Insert (Create): Uses a prepared statement to safely insert data into the database
- prepare() creates a statement template with placeholders (?)
- execute() runs the statement, replacing placeholders with values from the array
- This approach prevents SQL injection by separating SQL code from user data
Select (Read): Retrieves all records from the users table
- query() executes a simple SELECT statement
- fetchAll() returns all results as an array of rows
- The $users variable now contains all user records

Using prepared statements for any queries involving user input is a security best practice, as it prevents SQL injection attacks where malicious SQL could be injected through user inputs.

Sessions and Cookies

Session Management

session_start();
$_SESSION['user_id'] = 123;
$_SESSION['username'] = "john_doe";

// Destroying session
session_destroy();

Sessions allow you to store user information across multiple page requests:

session_start() initializes a session or resumes an existing one. This must be called before accessing any session variables and before any output is sent to the browser.
Session variables are stored in the superglobal $_SESSION array. Here we store a user ID (123) and username (“john_doe”), which will persist across pages as long as the session is active.
session_destroy() removes all session data, effectively logging the user out. Sessions typically expire after a period of inactivity or when the browser is closed, depending on server configuration.

Sessions are server-side storage, making them more secure for sensitive information like authentication status or user privileges.

// Setting cookie
setcookie("user", "john_doe", time() + 3600, "/");

// Reading cookie
if(isset($_COOKIE["user"])) {
    echo $_COOKIE["user"];
}

Cookies store small pieces of data on the client’s browser:

setcookie() creates a cookie with the following parameters:
- Name: “user” (how you’ll access the cookie later)
- Value: “john_doe” (the data stored in the cookie)
- Expiration: current time + 3600 seconds (1 hour from now)
- Path: “/” (cookie is available site-wide)
Reading cookies is done through the $_COOKIE superglobal array. The isset() check verifies the cookie exists before attempting to use it.

Unlike sessions, cookies are stored on the client-side and are subject to user browser settings. They’re useful for non-sensitive data like preferences or tracking information, but shouldn’t store sensitive data like passwords.

Security Best Practices

Input Validation

// Sanitizing input
$clean_email = filter_var($email, FILTER_SANITIZE_EMAIL);
$clean_url = filter_var($url, FILTER_SANITIZE_URL);

// Validating input
if(filter_var($clean_email, FILTER_VALIDATE_EMAIL)) {
    // Valid email
}

This code demonstrates proper input handling using PHP’s filter functions:

Sanitizing removes potentially dangerous characters from inputs:
- FILTER_SANITIZE_EMAIL removes invalid characters for email addresses
- FILTER_SANITIZE_URL removes characters not permitted in URLs
Validating checks if the sanitized input meets expected format rules:
- FILTER_VALIDATE_EMAIL returns the input if it’s a valid email format, otherwise false
- The if statement executes code only when the email is valid

This two-step approach (sanitize then validate) is a security best practice that helps prevent various attacks including cross-site scripting (XSS) and injection attacks.

SQL Injection Prevention

// Using prepared statements
$stmt = $pdo->prepare("SELECT * FROM users WHERE id = ?");
$stmt->execute([$user_id]);

SQL injection is one of the most common web vulnerabilities. This code demonstrates the proper way to prevent it:

Instead of directly inserting variables into SQL strings (e.g., "SELECT * FROM users WHERE id = $user_id"), prepared statements separate the SQL command from the data.
The question mark (?) acts as a placeholder. When execute() is called, PDO safely binds the value to the placeholder, ensuring special characters in $user_id are properly escaped.
This prevents attackers from injecting malicious SQL commands through user inputs, as the database treats the entire input as a single parameter value rather than executable SQL.

Always use prepared statements when incorporating user input into database queries, even for seemingly harmless data.

Password Hashing

// Hashing password
$hashed_password = password_hash($password, PASSWORD_DEFAULT);

// Verifying password
if(password_verify($password, $hashed_password)) {
    // Password is correct
}

Never store plain-text passwords! This code shows the proper password handling:

password_hash() creates a secure one-way hash of the password:
- PASSWORD_DEFAULT automatically uses the strongest algorithm currently available
- The function generates a random salt and includes it in the hash
- The resulting hash is different each time, even for the same password
password_verify() safely checks if a password matches a hash:
- It extracts the algorithm, cost, and salt from the hash
- Then applies the same hashing process to the input password
- Returns true only if the result matches the stored hash

This approach ensures passwords are stored securely. Even if your database is compromised, the actual passwords remain protected.

Performance Optimization

Code Optimization

Use single quotes for strings without variables
Avoid unnecessary loops
Implement caching when possible
Minimize database queries

These best practices significantly improve PHP application performance:

Single quotes process faster than double quotes because PHP doesn’t search for variables inside them
Loops are computationally expensive; combine operations when possible and avoid nested loops
Caching saves results of expensive operations for reuse, reducing processing time
Database queries are often the biggest bottleneck; combine queries and use indexes efficiently

Caching Strategies

// Simple file caching
$cache_file = 'cache/data.cache';
if (file_exists($cache_file) && (time() - filemtime($cache_file) < 3600)) {
    $data = file_get_contents($cache_file);
} else { // Get fresh data
    $data = getData();
    file_put_contents($cache_file, $data);
}

This implements a basic file-based caching system:

First, it checks if a cache file exists AND if it’s less than an hour old (3600 seconds)
- filemtime() returns the last modification time of the file
If a fresh cache exists, it loads the cached data with file_get_contents()
If no cache exists or it’s expired, it:
- Calls getData() (a function that presumably retrieves fresh data)
- Saves the new data to the cache file using file_put_contents()

This approach significantly reduces processing time for expensive operations by storing results temporarily. For production applications, consider using dedicated caching systems like Redis or Memcached for better performance.

Debugging and Testing

Debugging Tools

// Error reporting
error_reporting(E_ALL);
ini_set('display_errors', 1);

// Debug output
var_dump($variable);
print_r($array);

These are essential debugging techniques for PHP developers:

Error reporting configuration:
- error_reporting(E_ALL) sets PHP to report all types of errors, warnings, and notices
- ini_set('display_errors', 1) ensures errors are displayed in the browser output
- This configuration should only be used in development, not production environments
Inspection functions:
- var_dump($variable) outputs detailed information about a variable including its type and value
- print_r($array) provides a more readable format for arrays and objects
- Both functions are invaluable for understanding what data your code is working with at runtime

These tools help identify and fix issues during development before code reaches production.

Common Debug Techniques

// Log to file
error_log("Debug message", 3, "debug.log");

// Debug backtrace
debug_print_backtrace();

These advanced debugging techniques help with complex applications:

error_log() writes messages to a log file:
- First parameter is the message to log
- Second parameter (3) specifies appending to a file
- Third parameter is the file path
- This is safer for production environments than displaying errors on screen
debug_print_backtrace() displays the current call stack (function call history):
- Shows which functions were called before reaching the current point
- Includes file names, line numbers, and function arguments
- Extremely useful for tracking down where an error originated

These techniques help diagnose problems in larger applications where simple echo statements aren’t practical.

Advanced Topics

Object-Oriented Programming

PHP supports full object-oriented programming (OOP), allowing you to organize code into reusable classes. Here’s a comprehensive overview of PHP’s OOP features:

Basic Class Structure

class User {
    // Properties (variables)
    private $name;
    private $email;
    
    // Constructor - runs when creating new objects
    public function __construct($name, $email = null) {
        $this->name = $name;
        $this->email = $email;
    }
    
    // Methods (functions)
    public function getName() {
        return $this->name;
    }
    
    public function setName($name) {
        $this->name = $name;
    }
    
    public function getEmail() {
        return $this->email;
    }
}

// Creating an object
$user = new User("John", "john@example.com");
echo $user->getName(); // Outputs: John
$user->setName("Jane");
echo $user->getName(); // Outputs: Jane

This example shows a User class with properties, a constructor, and methods. The $this keyword refers to the current object instance. Access modifiers (public, private, protected) control how properties and methods can be accessed.

Inheritance

class Person {
    protected $name;
    
    public function __construct($name) {
        $this->name = $name;
    }
    
    public function introduce() {
        return "Hi, I'm {$this->name}";
    }
}

class Employee extends Person {
    private $position;
    
    public function __construct($name, $position) {
        parent::__construct($name); // Call parent constructor
        $this->position = $position;
    }
    
    public function introduce() {
        return parent::introduce() . " and I work as a {$this->position}";
    }
}

$employee = new Employee("Sarah", "Developer");
echo $employee->introduce(); // Outputs: Hi, I'm Sarah and I work as a Developer

Inheritance allows a class to inherit properties and methods from another class. The extends keyword creates a child class. The parent:: syntax calls methods from the parent class. The protected access modifier makes properties/methods available to the class and its children.

Interfaces

interface Notifiable {
    public function sendNotification($message);
}

interface Loggable {
    public function logActivity($activity);
}

class Customer implements Notifiable, Loggable {
    private $name;
    private $email;
    
    public function __construct($name, $email) {
        $this->name = $name;
        $this->email = $email;
    }
    
    public function sendNotification($message) {
        // Code to send email notification
        echo "Sending '{$message}' to {$this->email}";
    }
    
    public function logActivity($activity) {
        // Code to log activity
        echo "Logging: {$this->name} performed {$activity}";
    }
}

Interfaces define contracts that classes must implement. A class can implement multiple interfaces, requiring it to include all methods defined in those interfaces. Interfaces promote consistency across different classes that perform similar functions.

Traits

trait Timestamps {
    private $createdAt;
    private $updatedAt;
    
    public function create() {
        $this->createdAt = date('Y-m-d H:i:s');
        $this->updatedAt = $this->createdAt;
    }
    
    public function update() {
        $this->updatedAt = date('Y-m-d H:i:s');
    }
    
    public function getCreatedAt() {
        return $this->createdAt;
    }
    
    public function getUpdatedAt() {
        return $this->updatedAt;
    }
}

class Post {
    use Timestamps; // Include the trait
    
    private $title;
    private $content;
    
    public function __construct($title, $content) {
        $this->title = $title;
        $this->content = $content;
        $this->create(); // From the trait
    }
}

$post = new Post("PHP Traits", "Traits are awesome!");
echo $post->getCreatedAt(); // From the trait

Traits provide a mechanism for code reuse in single inheritance languages like PHP. They allow you to reuse methods across different classes without requiring inheritance. The use keyword includes a trait in a class.

Magic Methods

class Product {
    private $data = [];
    
    // Magic method for setting inaccessible/non-existent properties
    public function __set($name, $value) {
        $this->data[$name] = $value;
    }
    
    // Magic method for getting inaccessible/non-existent properties
    public function __get($name) {
        return isset($this->data[$name]) ? $this->data[$name] : null;
    }
    
    // Magic method for string conversion
    public function __toString() {
        return json_encode($this->data);
    }
}

$product = new Product();
$product->name = "Laptop"; // Calls __set()
$product->price = 999.99;  // Calls __set()
echo $product->name;       // Calls __get(), outputs: Laptop
echo $product;             // Calls __toString(), outputs JSON representation

PHP provides special “magic” methods that are triggered by specific actions. They start with double underscores (__). Common magic methods include:

__construct(): Called when creating an object
__destruct(): Called when object is destroyed
__get() and __set(): For accessing properties
__call(): For calling inaccessible methods
__toString(): Called when object is used as a string

Static Members

class Configuration {
    // Static property (shared across all instances)
    private static $settings = [
        'debug' => false,
        'timezone' => 'UTC'
    ];
    
    // Static method (callable without instance)
    public static function getSetting($key) {
        return isset(self::$settings[$key]) ? self::$settings[$key] : null;
    }
    
    public static function setSetting($key, $value) {
        self::$settings[$key] = $value;
    }
}

// Using static methods (no instance needed)
Configuration::setSetting('debug', true);
echo Configuration::getSetting('debug'); // Outputs: 1 (true)

Static properties and methods belong to the class itself, not to instances. They’re accessed using the self:: keyword within the class or the ClassName:: syntax outside the class. Static members are useful for utility methods or shared data.

OOP is a powerful paradigm that helps organize and structure code, particularly for larger applications. It promotes concepts like encapsulation (hiding implementation details), inheritance (reusing code), and polymorphism (interface-based programming), which lead to more maintainable and flexible code.

Regular Expressions

// Pattern matching
if (preg_match("/^[a-zA-Z0-9]+$/", $string)) {
    echo "Valid string";
}

// String replacement
$text = preg_replace("/[^a-zA-Z0-9]/", "", $text);

Regular expressions provide powerful pattern matching capabilities:

preg_match() tests if a string matches a pattern:
- The pattern /^[a-zA-Z0-9]+$/ means “string contains only alphanumeric characters”
- ^ indicates start of string, $ indicates end
- [a-zA-Z0-9] matches any letter or digit
- + means “one or more of the previous element”
- Returns 1 if pattern matches, 0 if not, or false on error
preg_replace() performs search and replace using patterns:
- The pattern /[^a-zA-Z0-9]/ means “any character that is NOT alphanumeric”
- These characters are replaced with an empty string (removed)
- This effectively strips all special characters from the text

Regular expressions are extremely powerful but can be complex. They’re ideal for validation, parsing, and text manipulation tasks.

Package Management

# Installing Composer
curl -sS https://getcomposer.org/installer | php
mv composer.phar /usr/local/bin/composer

# Installing package
composer require vendor/package

Composer is PHP’s standard dependency manager:

Installation process:
- Downloads the installer script using curl
- Executes the script with PHP to create the composer.phar file
- Moves the file to make Composer available system-wide
Using Composer:
- composer require vendor/package downloads and installs a package
- Automatically manages dependencies (packages needed by your packages)
- Creates autoload files for easy inclusion of classes

Composer revolutionized PHP development by making it easy to use and share code libraries. It’s now considered essential for professional PHP development.

Conclusion and Next Steps

This guide has covered the fundamental aspects of PHP programming. To continue your learning journey:

Practice building small projects
Explore frameworks like Laravel or Symfony
Join PHP communities and forums
Contribute to open-source projects
Stay updated with PHP releases and best practices

Remember that becoming proficient in PHP requires consistent practice and continuous learning. Start with small projects and gradually tackle more complex applications as your skills improve.

Higherpass