Premium Content

PHP FUNDAMENTALS

Learn the core concepts of PHP programming

Beginner

Module 1: PHP Fundamentals

PHP is a popular general-purpose scripting language that is especially suited to web development. It is fast, flexible, and pragmatic, powering everything from your blog to the most popular websites in the world.

Try It Yourself:

PHP Code

// PHP Fundamentals - Basic Syntax and Output

// Variables and Data Types
$name = "John Doe";
$age = 25;
$price = 19.99;
$isStudent = true;
$courses = ["PHP", "MySQL", "JavaScript"];

// Output with echo
echo "<h3>Welcome to PHP Programming!</h3>";
echo "Name: " . $name . "<br>";
echo "Age: $age<br>"; // Variable interpolation
echo "Price: \${$price}<br>";
echo "Is Student: " . ($isStudent ? "Yes" : "No") . "<br>";

// Conditional Statements
if ($age >= 18) {
    echo "<p>You are an adult.</p>";
} else {
    echo "<p>You are a minor.</p>";
}

// Loops
echo "<h4>Course List:</h4>";
echo "<ul>";
foreach ($courses as $course) {
    echo "<li>$course</li>";
}
echo "</ul>";

// Functions
function calculateArea($width, $height) {
    return $width * $height;
}

$area = calculateArea(5, 10);
echo "Area: " . $area . " square units<br>";

// Working with Arrays
$student = [
    "name" => "Alice",
    "grade" => "A",
    "subjects" => ["Math", "Science", "History"]
];

echo "<h4>Student Information:</h4>";
echo "Name: " . $student["name"] . "<br>";
echo "First Subject: " . $student["subjects"][0] . "<br>";

// Date and Time
echo "<p>Current date: " . date("Y-m-d H:i:s") . "</p>";

Code Analysis

This PHP Fundamentals example demonstrates:

Basic Syntax: PHP tags, variables, and output
Data Types: Strings, integers, floats, booleans, and arrays
Control Structures: Conditional statements and loops
Functions: Creating and using custom functions
Arrays: Indexed and associative arrays
Date/Time: Working with dates and times

Key Takeaway: PHP provides a simple yet powerful syntax for web development with extensive built-in functions and flexibility.

Key PHP Concepts:

Variables - Store and manipulate data with $ prefix
Data Types - Strings, integers, floats, booleans, arrays, objects
Control Structures - if/else, switch, while, for, foreach
Functions - Reusable code blocks with parameters
Arrays - Indexed, associative, and multidimensional
Superglobals - $_GET, $_POST, $_SESSION, $_SERVER
Error Handling - Try/catch and custom error handling

Premium Content

PHP SYNTAX & FUNCTIONS

Master PHP syntax and built-in functions

Beginner

Module 2: PHP Syntax & Functions

PHP offers a rich set of built-in functions for string manipulation, array handling, file operations, and more. Understanding these functions is key to writing efficient PHP code.

Try It Yourself:

PHP Code

// PHP Functions and Built-in Capabilities

// String Functions
$text = "  Welcome to PHP Programming!  ";
echo "<h3>String Functions:</h3>";
echo "Original: '$text'<br>";
echo "Trimmed: '" . trim($text) . "'<br>";
echo "Length: " . strlen($text) . "<br>";
echo "Uppercase: " . strtoupper($text) . "<br>";
echo "Lowercase: " . strtolower($text) . "<br>";
echo "Word Count: " . str_word_count($text) . "<br>";
echo "Replace: " . str_replace("PHP", "Web", $text) . "<br>";
echo "Substring: " . substr($text, 5, 10) . "<br>";

// Array Functions
$fruits = ["apple", "banana", "orange", "grape"];
echo "<h3>Array Functions:</h3>";
echo "Original Array: " . implode(", ", $fruits) . "<br>";
echo "Array Length: " . count($fruits) . "<br>";

// Add and remove elements
array_push($fruits, "mango");
echo "After push: " . implode(", ", $fruits) . "<br>";

$lastFruit = array_pop($fruits);
echo "Popped: $lastFruit<br>";
echo "After pop: " . implode(", ", $fruits) . "<br>";

// Array searching
$search = "orange";
if (in_array($search, $fruits)) {
    echo "'$search' found in array<br>";
} else {
    echo "'$search' not found in array<br>";
}

// Math Functions
echo "<h3>Math Functions:</h3>";
$number = 25.7;
echo "Number: $number<br>";
echo "Ceiling: " . ceil($number) . "<br>";
echo "Floor: " . floor($number) . "<br>";
echo "Round: " . round($number) . "<br>";
echo "Square Root: " . sqrt($number) . "<br>";
echo "Random Number: " . rand(1, 100) . "<br>";

// Date and Time Functions
echo "<h3>Date and Time Functions:</h3>";
echo "Current Date: " . date('Y-m-d') . "<br>";
echo "Current Time: " . date('H:i:s') . "<br>";
echo "Full Date/Time: " . date('l, F j, Y \\a\\t g:i A') . "<br>";

$futureDate = strtotime('+1 week');
echo "Next Week: " . date('Y-m-d', $futureDate) . "<br>";

// Custom Functions with Parameters
function formatCurrency($amount, $currency = '$') {
    return $currency . number_format($amount, 2);
}

echo "<h3>Custom Functions:</h3>";
echo "Formatted Amount: " . formatCurrency(1234.56) . "<br>";
echo "Euro Amount: " . formatCurrency(1234.56, '€') . "<br>";

// Variable Functions
$functionName = 'strtoupper';
echo "Variable Function: " . $functionName('hello world') . "<br>";

Functions Analysis

This PHP functions example demonstrates:

String Functions: Manipulating and analyzing text data
Array Functions: Working with arrays - sorting, searching, modifying
Math Functions: Mathematical operations and calculations
Date/Time Functions: Working with dates and time formatting
File System Functions: Basic file operations and checks
Custom Functions: Creating reusable code with parameters
Variable Functions: Using variables as function names

Key Takeaway: PHP's extensive built-in function library makes common programming tasks simple and efficient, while custom functions allow for code reuse and organization.

Premium Content

PHP OOP & CLASSES

Object-Oriented Programming in PHP

Intermediate

Module 3: PHP Object-Oriented Programming

Object-Oriented Programming (OOP) in PHP allows you to create more modular, maintainable, and scalable code. PHP supports classes, objects, inheritance, interfaces, and traits for modern software development.

Try It Yourself:

PHP Code

// PHP Object-Oriented Programming

// Basic Class Definition
class Car {
    // Properties
    public $brand;
    public $model;
    public $year;
    private $mileage;
    
    // Constructor
    public function __construct($brand, $model, $year) {
        $this->brand = $brand;
        $this->model = $model;
        $this->year = $year;
        $this->mileage = 0;
    }
    
    // Methods
    public function startEngine() {
        return "The {$this->brand} {$this->model}'s engine is starting...";
    }
    
    public function drive($distance) {
        $this->mileage += $distance;
        return "Driving {$distance} miles. Total mileage: {$this->mileage}";
    }
    
    public function getMileage() {
        return $this->mileage;
    }
    
    // Static method
    public static function createFromArray($data) {
        return new self($data['brand'], $data['model'], $data['year']);
    }
}

// Using the Car class
echo "<h3>Basic OOP Example:</h3>";
$myCar = new Car("Toyota", "Camry", 2022);
echo $myCar->startEngine() . "<br>";
echo $myCar->drive(50) . "<br>";
echo $myCar->drive(25) . "<br>";
echo "Current Mileage: " . $myCar->getMileage() . "<br>";

// Inheritance
class ElectricCar extends Car {
    private $batteryLevel;
    
    public function __construct($brand, $model, $year) {
        parent::__construct($brand, $model, $year);
        $this->batteryLevel = 100;
    }
    
    public function charge($percentage) {
        $this->batteryLevel = min(100, $this->batteryLevel + $percentage);
        return "Battery charged to {$this->batteryLevel}%";
    }
    
    public function getBatteryLevel() {
        return $this->batteryLevel;
    }
    
    // Overriding parent method
    public function startEngine() {
        return "The {$this->brand} {$this->model} is powering on silently...";
    }
}

echo "<h3>Inheritance Example:</h3>";
$tesla = new ElectricCar("Tesla", "Model 3", 2023);
echo $tesla->startEngine() . "<br>";
echo $tesla->drive(30) . "<br>";
echo $tesla->charge(50) . "<br>";
echo "Battery Level: " . $tesla->getBatteryLevel() . "%<br>";

// Interfaces
interface PaymentInterface {
    public function processPayment($amount);
    public function getPaymentDetails();
}

class CreditCardPayment implements PaymentInterface {
    private $cardNumber;
    private $expiryDate;
    
    public function __construct($cardNumber, $expiryDate) {
        $this->cardNumber = $cardNumber;
        $this->expiryDate = $expiryDate;
    }
    
    public function processPayment($amount) {
        return "Processing credit card payment of \${$amount}";
    }
    
    public function getPaymentDetails() {
        return "Credit Card ending in " . substr($this->cardNumber, -4);
    }
}

class PayPalPayment implements PaymentInterface {
    private $email;
    
    public function __construct($email) {
        $this->email = $email;
    }
    
    public function processPayment($amount) {
        return "Processing PayPal payment of \${$amount} from {$this->email}";
    }
    
    public function getPaymentDetails() {
        return "PayPal account: {$this->email}";
    }
}

echo "<h3>Interface Example:</h3>";
$payments = [
    new CreditCardPayment("4111111111111111", "12/25"),
    new PayPalPayment("user@example.com")
];

foreach ($payments as $payment) {
    echo $payment->processPayment(100) . "<br>";
    echo $payment->getPaymentDetails() . "<br><br>";
}

OOP Analysis

This PHP OOP example demonstrates:

Classes and Objects: Creating blueprints and instances
Properties and Methods: Data and behavior encapsulation
Constructors: Object initialization
Inheritance: Extending classes and overriding methods
Interfaces: Defining contracts for classes
Abstract Classes: Creating base classes with partial implementation
Access Modifiers: Controlling visibility (public, private, protected)
Static Methods: Class-level functionality

Key Takeaway: PHP's OOP features enable you to write organized, reusable, and maintainable code that models real-world concepts and relationships effectively.

PHP OOP Features:

Classes & Objects - Blueprints and instances
Inheritance - Extending parent classes
Interfaces - Defining method contracts
Abstract Classes - Partial implementation classes
Traits - Code reuse in horizontal inheritance
Visibility - Public, private, and protected access
Static Members - Class-level properties and methods
Magic Methods - Special methods like __construct, __toString

Premium Content

PHP & MYSQL

Database integration with MySQL

Intermediate

Module 4: PHP & MySQL Database Integration

PHP's integration with MySQL allows you to create dynamic, data-driven web applications. Learn how to connect to databases, execute queries, and handle data securely and efficiently.

Try It Yourself:

PHP Code

// PHP and MySQL Database Integration

// Database Connection Class
class Database {
    private $connection;
    
    public function __construct($host, $dbname, $username, $password) {
        try {
            $this->connection = new PDO(
                "mysql:host=$host;dbname=$dbname;charset=utf8mb4",
                $username,
                $password,
                [
                    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
                    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
                ]
            );
        } catch (PDOException $e) {
            die("Connection failed: " . $e->getMessage());
        }
    }
    
    public function getConnection() {
        return $this->connection;
    }
}

// User Model Class
class User {
    private $db;
    
    public function __construct($database) {
        $this->db = $database->getConnection();
    }
    
    // Create user
    public function create($name, $email, $password) {
        $hashedPassword = password_hash($password, PASSWORD_DEFAULT);
        $sql = "INSERT INTO users (name, email, password) VALUES (:name, :email, :password)";
        
        $stmt = $this->db->prepare($sql);
        $stmt->execute([
            ':name' => $name,
            ':email' => $email,
            ':password' => $hashedPassword
        ]);
        
        return $this->db->lastInsertId();
    }
    
    // Get user by ID
    public function getById($id) {
        $sql = "SELECT * FROM users WHERE id = :id";
        $stmt = $this->db->prepare($sql);
        $stmt->execute([':id' => $id]);
        
        return $stmt->fetch();
    }
    
    // Get all users
    public function getAll() {
        $sql = "SELECT id, name, email, created_at FROM users ORDER BY created_at DESC";
        $stmt = $this->db->prepare($sql);
        $stmt->execute();
        
        return $stmt->fetchAll();
    }
    
    // Update user
    public function update($id, $name, $email) {
        $sql = "UPDATE users SET name = :name, email = :email WHERE id = :id";
        $stmt = $this->db->prepare($sql);
        
        return $stmt->execute([
            ':name' => $name,
            ':email' => $email,
            ':id' => $id
        ]);
    }
    
    // Delete user
    public function delete($id) {
        $sql = "DELETE FROM users WHERE id = :id";
        $stmt = $this->db->prepare($sql);
        
        return $stmt->execute([':id' => $id]);
    }
    
    // Verify user credentials
    public function verifyCredentials($email, $password) {
        $sql = "SELECT * FROM users WHERE email = :email";
        $stmt = $this->db->prepare($sql);
        $stmt->execute([':email' => $email]);
        
        $user = $stmt->fetch();
        
        if ($user && password_verify($password, $user['password'])) {
            return $user;
        }
        
        return false;
    }
}

// Product Model Class
class Product {
    private $db;
    
    public function __construct($database) {
        $this->db = $database->getConnection();
    }
    
    // Create product
    public function create($name, $description, $price, $category_id) {
        $sql = "INSERT INTO products (name, description, price, category_id) 
                VALUES (:name, :description, :price, :category_id)";
        
        $stmt = $this->db->prepare($sql);
        $stmt->execute([
            ':name' => $name,
            ':description' => $description,
            ':price' => $price,
            ':category_id' => $category_id
        ]);
        
        return $this->db->lastInsertId();
    }
    
    // Get products with pagination
    public function getProducts($page = 1, $limit = 10) {
        $offset = ($page - 1) * $limit;
        
        $sql = "SELECT p.*, c.name as category_name 
                FROM products p 
                LEFT JOIN categories c ON p.category_id = c.id 
                ORDER BY p.created_at DESC 
                LIMIT :limit OFFSET :offset";
        
        $stmt = $this->db->prepare($sql);
        $stmt->bindValue(':limit', $limit, PDO::PARAM_INT);
        $stmt->bindValue(':offset', $offset, PDO::PARAM_INT);
        $stmt->execute();
        
        return $stmt->fetchAll();
    }
    
    // Search products
    public function search($query) {
        $sql = "SELECT * FROM products 
                WHERE name LIKE :query OR description LIKE :query 
                ORDER BY name";
        
        $stmt = $this->db->prepare($sql);
        $stmt->execute([':query' => "%$query%"]);
        
        return $stmt->fetchAll();
    }
}

// Usage Examples
echo "<h3>PHP MySQL Integration Examples:</h3>";

// Note: In a real application, you would establish a database connection
// For this example, we'll simulate the database operations

echo "<h4>User Management Simulation:</h4>";
echo "• User creation with password hashing<br>";
echo "• User authentication with credential verification<br>";
echo "• CRUD operations (Create, Read, Update, Delete)<br>";
echo "• Prepared statements for security<br>";

echo "<h4>Product Management Simulation:</h4>";
echo "• Product creation with categories<br>";
echo "• Paginated product listings<br>";
echo "• Search functionality<br>";
echo "• JOIN operations for related data<br>";

echo "<h4>Security Features:</h4>";
echo "• Password hashing with password_hash()<br>";
echo "• Prepared statements to prevent SQL injection<br>";
echo "• Input validation and sanitization<br>";
echo "• Error handling with exceptions<br>";

echo "<p><strong>Note:</strong> This is a simulation. In a live environment, these functions would interact with an actual MySQL database.</p>";

Database Analysis

This PHP & MySQL example demonstrates:

Database Connection: Using PDO for secure database connections
CRUD Operations: Create, Read, Update, Delete database records
Prepared Statements: Preventing SQL injection attacks
Data Models: Organizing database interactions in classes
Password Security: Hashing passwords with password_hash()
Error Handling: Proper exception handling for database errors
JOIN Operations: Combining data from multiple tables
Pagination: Implementing paginated results for large datasets

Key Takeaway: PHP's PDO extension provides a secure, consistent interface for working with databases, while proper architecture ensures maintainable and scalable database interactions.

PHP Database Features:

PDO - PHP Data Objects for database access
MySQLi - MySQL improved extension
Prepared Statements - Secure SQL query execution
Transactions - Atomic database operations
Error Handling - Database exception management
Data Sanitization - Input validation and cleaning
ORM - Object-Relational Mapping libraries
Query Building - Programmatic SQL query construction

Premium Content

PHP SECURITY

Secure PHP application development

Intermediate

Module 5: PHP Security Best Practices

Security is crucial in web development. PHP provides various tools and techniques to protect your applications from common vulnerabilities like SQL injection, XSS, CSRF, and more.

Try It Yourself:

PHP Code

// PHP Security Best Practices

// Input Validation and Sanitization
class Security {
    
    // Validate email
    public static function validateEmail($email) {
        if (filter_var($email, FILTER_VALIDATE_EMAIL)) {
            return filter_var($email, FILTER_SANITIZE_EMAIL);
        }
        return false;
    }
    
    // Validate and sanitize string
    public static function sanitizeString($input) {
        // Remove HTML tags and encode special characters
        $cleaned = strip_tags($input);
        $cleaned = htmlspecialchars($cleaned, ENT_QUOTES, 'UTF-8');
        return trim($cleaned);
    }
    
    // Validate integer
    public static function validateInteger($input) {
        if (filter_var($input, FILTER_VALIDATE_INT) !== false) {
            return (int)$input;
        }
        return false;
    }
    
    // Validate URL
    public static function validateURL($url) {
        if (filter_var($url, FILTER_VALIDATE_URL)) {
            return filter_var($url, FILTER_SANITIZE_URL);
        }
        return false;
    }
    
    // Generate CSRF token
    public static function generateCSRFToken() {
        if (empty($_SESSION['csrf_token'])) {
            $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
        }
        return $_SESSION['csrf_token'];
    }
    
    // Validate CSRF token
    public static function validateCSRFToken($token) {
        if (isset($_SESSION['csrf_token']) && hash_equals($_SESSION['csrf_token'], $token)) {
            return true;
        }
        return false;
    }
    
    // Password hashing and verification
    public static function hashPassword($password) {
        return password_hash($password, PASSWORD_DEFAULT);
    }
    
    public static function verifyPassword($password, $hash) {
        return password_verify($password, $hash);
    }
    
    // XSS prevention for output
    public static function escapeOutput($data) {
        if (is_array($data)) {
            return array_map('self::escapeOutput', $data);
        }
        return htmlspecialchars($data, ENT_QUOTES, 'UTF-8');
    }
}

// Secure Form Handling Example
class SecureFormHandler {
    private $errors = [];
    
    public function handleRegistration($postData) {
        // Validate CSRF token
        if (!Security::validateCSRFToken($postData['csrf_token'] ?? '')) {
            $this->errors[] = "Invalid CSRF token";
            return false;
        }
        
        // Validate and sanitize inputs
        $name = Security::sanitizeString($postData['name'] ?? '');
        $email = Security::validateEmail($postData['email'] ?? '');
        $password = $postData['password'] ?? '';
        
        // Validation checks
        if (empty($name)) {
            $this->errors[] = "Name is required";
        }
        
        if (!$email) {
            $this->errors[] = "Valid email is required";
        }
        
        if (strlen($password) < 8) {
            $this->errors[] = "Password must be at least 8 characters";
        }
        
        // If no errors, process the form
        if (empty($this->errors)) {
            $hashedPassword = Security::hashPassword($password);
            
            // In a real application, you would save to database here
            echo "<div class='success'>Registration successful!</div>";
            echo "Name: " . Security::escapeOutput($name) . "<br>";
            echo "Email: " . Security::escapeOutput($email) . "<br>";
            echo "Password Hash: " . $hashedPassword . "<br>";
            
            return true;
        }
        
        return false;
    }
    
    public function getErrors() {
        return $this->errors;
    }
}

// File Upload Security
class SecureFileUpload {
    private $allowedTypes = ['image/jpeg', 'image/png', 'image/gif'];
    private $maxSize = 2 * 1024 * 1024; // 2MB
    private $uploadErrors = [];
    
    public function upload($file) {
        // Check for upload errors
        if ($file['error'] !== UPLOAD_ERR_OK) {
            $this->uploadErrors[] = "Upload error: " . $file['error'];
            return false;
        }
        
        // Check file size
        if ($file['size'] > $this->maxSize) {
            $this->uploadErrors[] = "File too large. Maximum size: 2MB";
            return false;
        }
        
        // Check file type
        $finfo = finfo_open(FILEINFO_MIME_TYPE);
        $mimeType = finfo_file($finfo, $file['tmp_name']);
        finfo_close($finfo);
        
        if (!in_array($mimeType, $this->allowedTypes)) {
            $this->uploadErrors[] = "Invalid file type. Allowed: JPEG, PNG, GIF";
            return false;
        }
        
        // Generate secure filename
        $extension = pathinfo($file['name'], PATHINFO_EXTENSION);
        $filename = uniqid() . '_' . bin2hex(random_bytes(8)) . '.' . $extension;
        $destination = 'uploads/' . $filename;
        
        // Move uploaded file
        if (move_uploaded_file($file['tmp_name'], $destination)) {
            return $filename;
        }
        
        $this->uploadErrors[] = "Failed to move uploaded file";
        return false;
    }
    
    public function getUploadErrors() {
        return $this->uploadErrors;
    }
}

// Usage Examples
echo "<h3>PHP Security Examples:</h3>";

// Generate CSRF token for form
$csrfToken = Security::generateCSRFToken();

echo "<h4>Input Validation & Sanitization:</h4>";
$testEmail = "user@example.com<script>";
$testString = "<script>alert('XSS')</script>Hello World";

echo "Original Email: " . htmlspecialchars($testEmail) . "<br>";
echo "Validated Email: " . Security::validateEmail($testEmail) . "<br>";
echo "Original String: " . htmlspecialchars($testString) . "<br>";
echo "Sanitized String: " . Security::sanitizeString($testString) . "<br>";

echo "<h4>Password Security:</h4>";
$password = "MySecurePassword123";
$hash = Security::hashPassword($password);
echo "Password: ********<br>";
echo "Hash: $hash<br>";
echo "Verification: " . (Security::verifyPassword($password, $hash) ? "Success" : "Failed") . "<br>";

echo "<h4>CSRF Protection:</h4>";
echo "CSRF Token: $csrfToken<br>";
echo "Token Validation: " . (Security::validateCSRFToken($csrfToken) ? "Valid" : "Invalid") . "<br>";

echo "<h4>Secure Output:</h4>";
$userInput = "<script>alert('XSS Attack')</script>Welcome User";
echo "Unescaped: $userInput<br>";
echo "Escaped: " . Security::escapeOutput($userInput) . "<br>";

Security Analysis

This PHP Security example demonstrates:

Input Validation: Ensuring data meets expected criteria
Input Sanitization: Cleaning user input to prevent attacks
CSRF Protection: Preventing Cross-Site Request Forgery attacks
Password Security: Proper password hashing and verification
XSS Prevention: Output escaping to prevent Cross-Site Scripting
File Upload Security: Safe handling of file uploads
Session Security: Secure session management practices
Secure Headers: HTTP security headers configuration

Key Takeaway: Security should be implemented at every layer of your PHP application, from input validation to output escaping, with special attention to common web vulnerabilities.

PHP Security Features:

Input Validation - Data type and format checking
Sanitization - Cleaning user input
CSRF Protection - Cross-Site Request Forgery prevention
XSS Prevention - Cross-Site Scripting protection
SQL Injection Prevention - Prepared statements and parameterized queries
Password Hashing - Secure password storage
Session Security - Secure session management
File Upload Security - Safe file handling

Premium Content

PHP APIS & DEPLOYMENT

Build REST APIs and deploy PHP applications

Advanced

Module 6: PHP APIs and Deployment

Modern PHP applications often involve building RESTful APIs and deploying to production environments. This module covers API development, testing, and deployment strategies for PHP applications.

Try It Yourself:

PHP Code

// PHP REST API and Deployment

// Simple REST API Implementation
class RESTAPI {
    private $routes = [];
    private $requestMethod;
    private $requestUri;
    private $requestData;
    
    public function __construct() {
        $this->requestMethod = $_SERVER['REQUEST_METHOD'] ?? 'GET';
        $this->requestUri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
        $this->parseInput();
    }
    
    private function parseInput() {
        // Get JSON input
        $input = file_get_contents('php://input');
        $this->requestData = json_decode($input, true) ?? [];
        
        // Merge with GET/POST data
        if ($this->requestMethod === 'GET') {
            $this->requestData = array_merge($this->requestData, $_GET);
        } else {
            $this->requestData = array_merge($this->requestData, $_POST);
        }
    }
    
    public function addRoute($method, $path, $callback) {
        $this->routes[] = [
            'method' => strtoupper($method),
            'path' => $path,
            'callback' => $callback
        ];
    }
    
    public function run() {
        foreach ($this->routes as $route) {
            if ($this->matchRoute($route)) {
                try {
                    $response = call_user_func($route['callback'], $this->requestData);
                    $this->sendResponse($response);
                    return;
                } catch (Exception $e) {
                    $this->sendError($e->getMessage(), 500);
                    return;
                }
            }
        }
        
        $this->sendError('Route not found', 404);
    }
    
    private function matchRoute($route) {
        if ($route['method'] !== $this->requestMethod) {
            return false;
        }
        
        // Simple exact match for demo
        return $route['path'] === $this->requestUri;
    }
    
    private function sendResponse($data, $statusCode = 200) {
        http_response_code($statusCode);
        header('Content-Type: application/json');
        header('Access-Control-Allow-Origin: *');
        header('Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS');
        header('Access-Control-Allow-Headers: Content-Type, Authorization');
        
        echo json_encode([
            'status' => 'success',
            'data' => $data,
            'timestamp' => time()
        ]);
    }
    
    private function sendError($message, $statusCode = 400) {
        http_response_code($statusCode);
        header('Content-Type: application/json');
        
        echo json_encode([
            'status' => 'error',
            'message' => $message,
            'timestamp' => time()
        ]);
    }
}

// API Controllers
class UserController {
    private $users = []; // In real app, this would be a database
    
    public function __construct() {
        // Sample data
        $this->users = [
            1 => ['id' => 1, 'name' => 'John Doe', 'email' => 'john@example.com'],
            2 => ['id' => 2, 'name' => 'Jane Smith', 'email' => 'jane@example.com']
        ];
    }
    
    public function getUsers() {
        return array_values($this->users);
    }
    
    public function getUser($data) {
        $id = $data['id'] ?? null;
        if (!$id || !isset($this->users[$id])) {
            throw new Exception('User not found');
        }
        return $this->users[$id];
    }
    
    public function createUser($data) {
        $name = $data['name'] ?? '';
        $email = $data['email'] ?? '';
        
        if (empty($name) || empty($email)) {
            throw new Exception('Name and email are required');
        }
        
        $id = count($this->users) + 1;
        $this->users[$id] = [
            'id' => $id,
            'name' => $name,
            'email' => $email
        ];
        
        return $this->users[$id];
    }
    
    public function updateUser($data) {
        $id = $data['id'] ?? null;
        if (!$id || !isset($this->users[$id])) {
            throw new Exception('User not found');
        }
        
        if (isset($data['name'])) {
            $this->users[$id]['name'] = $data['name'];
        }
        
        if (isset($data['email'])) {
            $this->users[$id]['email'] = $data['email'];
        }
        
        return $this->users[$id];
    }
    
    public function deleteUser($data) {
        $id = $data['id'] ?? null;
        if (!$id || !isset($this->users[$id])) {
            throw new Exception('User not found');
        }
        
        unset($this->users[$id]);
        return ['message' => 'User deleted successfully'];
    }
}

// Product Controller
class ProductController {
    private $products = [];
    
    public function __construct() {
        $this->products = [
            1 => ['id' => 1, 'name' => 'Laptop', 'price' => 999.99, 'category' => 'Electronics'],
            2 => ['id' => 2, 'name' => 'Book', 'price' => 19.99, 'category' => 'Education']
        ];
    }
    
    public function getProducts() {
        return array_values($this->products);
    }
    
    public function searchProducts($data) {
        $query = $data['q'] ?? '';
        if (empty($query)) {
            return $this->getProducts();
        }
        
        $results = [];
        foreach ($this->products as $product) {
            if (stripos($product['name'], $query) !== false || 
                stripos($product['category'], $query) !== false) {
                $results[] = $product;
            }
        }
        
        return $results;
    }
}

// API Documentation Generator
class APIDocumentation {
    public static function generate($routes) {
        $docs = [
            'title' => 'PHP REST API Documentation',
            'version' => '1.0.0',
            'base_url' => '/api',
            'endpoints' => []
        ];
        
        foreach ($routes as $route) {
            $docs['endpoints'][] = [
                'method' => $route['method'],
                'path' => $route['path'],
                'description' => self::getEndpointDescription($route['path'])
            ];
        }
        
        return $docs;
    }
    
    private static function getEndpointDescription($path) {
        $descriptions = [
            '/api/users' => 'Get all users or create a new user',
            '/api/users/{id}' => 'Get, update, or delete a specific user',
            '/api/products' => 'Get all products or search products',
        ];
        
        return $descriptions[$path] ?? 'API endpoint';
    }
}

// API Usage Example
echo "<h3>PHP REST API Implementation:</h3>";

// Create API instance
$api = new RESTAPI();
$userController = new UserController();
$productController = new ProductController();

// Define routes
$routes = [
    ['method' => 'GET', 'path' => '/api/users'],
    ['method' => 'GET', 'path' => '/api/users/{id}'],
    ['method' => 'POST', 'path' => '/api/users'],
    ['method' => 'PUT', 'path' => '/api/users/{id}'],
    ['method' => 'DELETE', 'path' => '/api/users/{id}'],
    ['method' => 'GET', 'path' => '/api/products'],
    ['method' => 'GET', 'path' => '/api/products/search']
];

$docs = APIDocumentation::generate($routes);

echo "<h4>API Endpoints:</h4>";
foreach ($docs['endpoints'] as $endpoint) {
    echo "<strong>{$endpoint['method']} {$endpoint['path']}</strong><br>";
    echo "{$endpoint['description']}<br><br>";
}

echo "<h4>Sample API Response:</h4>";
echo "<pre>{\n";
echo "  \"status\": \"success\",\n";
echo "  \"data\": [\n";
echo "    {\n";
echo "      \"id\": 1,\n";
echo "      \"name\": \"John Doe\",\n";
echo "      \"email\": \"john@example.com\"\n";
echo "    }\n";
echo "  ],\n";
echo "  \"timestamp\": " . time() . "\n";
echo "}</pre>";

echo "<p><strong>Note:</strong> In a live API, you would call \$api->run() to handle incoming requests.</p>";

API & Deployment Analysis

This PHP API & Deployment example demonstrates:

REST API Implementation: Building RESTful APIs with proper HTTP methods
Route Handling: Managing different API endpoints and HTTP verbs
Controller Architecture: Organizing API logic in controller classes
JSON Responses: Proper API response formatting
Error Handling: Consistent error responses for API consumers
CORS Support: Cross-Origin Resource Sharing for web clients
API Documentation: Generating documentation for API endpoints
Environment Configuration: Different settings for development and production

Key Takeaway: Modern PHP applications can implement robust REST APIs with proper architecture, documentation, and deployment configurations for both development and production environments.

PHP API & Deployment Features:

REST API - Representational State Transfer APIs
Route Handling - URL routing and request method handling
JSON Processing - Input/output JSON data handling
CORS - Cross-Origin Resource Sharing configuration
Environment Config - Different settings per environment
API Documentation - Automatic documentation generation
Deployment - Production deployment strategies
Performance - Caching and optimization techniques

PRACTICE PLAYGROUND

Experiment with PHP concepts

Your PHP Playground: Try Your Own PHP Code

Use this space to experiment with everything you've learned about PHP web development. Try different functions, classes, and algorithms to see how they work. This is your sandbox to practice and explore the art of PHP programming.

PHP Code

// PHP Playground - Try Your Own Code!

/*
Experiment with:
- Custom functions and classes
- Database operations with MySQL
- File handling and manipulation
- API integrations
- Form processing and validation
- Your own creative ideas!
*/

// Example: User Management System
class User {
    private $name;
    private $email;
    private $role;
    
    public function __construct($name, $email, $role = "user") {
        $this->name = $name;
        $this->email = $email;
        $this->role = $role;
    }
    
    public function getUserInfo() {
        return [
            "name" => $this->name,
            "email" => $this->email,
            "role" => $this->role
        ];
    }
    
    public function displayInfo() {
        $info = $this->getUserInfo();
        echo "User: {$info['name']} ({$info['email']}) - Role: {$info['role']}";
    }
}

// Create users
$user1 = new User("John Smith", "john@example.com");
$user2 = new User("Admin User", "admin@example.com", "administrator");

echo "<h3>User Management System</h3>";
$user1->displayInfo();
echo "<br>";
$user2->displayInfo();

// Your experiments go here!
// Try creating:
// - Custom classes and methods
// - Database connection and queries
// - File upload and processing
// - API endpoints
// - Form validation
// - Your own creative ideas!

echo "<p>Welcome to the PHP Playground! Modify the code above to experiment.</p>";

Code Analysis

Practice Ideas for Your PHP Playground:

PHP Development Challenges:

Object-Oriented Programming: Implement classes for users, products, or orders
Database Operations: Connect to MySQL and perform CRUD operations
File Handling: Create file upload systems and log files
API Development: Build RESTful APIs with PHP
Security: Implement input validation and SQL injection prevention

Sample Projects to Try:

Blog System: Complete blog with posts, categories, and comments
E-commerce Site: Product catalog, shopping cart, and order management
User Management: Registration, login, and profile management
Content Management: Dynamic pages with admin panel
API Service: REST API for mobile apps or frontend frameworks

Remember: The key to mastering PHP is practice and experimentation. Don't be afraid to try new things and make mistakes!

Advanced PHP Challenges:

Implement complex applications:
- Multi-tenant SaaS application
- Real-time features with WebSockets
- Payment integration with Stripe or PayPal
- Search functionality with Elasticsearch
Create advanced API features:
- GraphQL API with PHP
- Webhook implementations
- Rate limiting and throttling
- API versioning strategies
Build deployment pipelines:
- CI/CD with GitHub Actions
- Docker containerization
- Kubernetes deployment
- Multi-environment configuration
Practice performance optimization:
- Database query optimization
- Caching strategies with Redis
- Background tasks with workers
- Static file optimization and CDN

Tips & Resources:

Start with simple projects and gradually increase complexity
Use version control (git) to track your progress
Read and understand the PHP source code for popular frameworks
Practice testing with PHPUnit
Study the PHP documentation thoroughly
Join PHP communities and contribute to open source

PHP FUNDAMENTALS

Learn the core concepts of PHP programming

Module 1: PHP Fundamentals

Try It Yourself:

This PHP Fundamentals example demonstrates:

Key PHP Concepts:

PHP SYNTAX & FUNCTIONS

Master PHP syntax and built-in functions

Module 2: PHP Syntax & Functions

Try It Yourself:

This PHP functions example demonstrates:

PHP Function Categories:

PHP OOP & CLASSES

Object-Oriented Programming in PHP

Module 3: PHP Object-Oriented Programming

Try It Yourself:

This PHP OOP example demonstrates:

PHP OOP Features:

PHP & MYSQL

Database integration with MySQL

Module 4: PHP & MySQL Database Integration

Try It Yourself:

This PHP & MySQL example demonstrates:

PHP Database Features:

PHP SECURITY

Secure PHP application development

Module 5: PHP Security Best Practices

Try It Yourself:

This PHP Security example demonstrates:

PHP Security Features:

PHP APIS & DEPLOYMENT

Build REST APIs and deploy PHP applications

Module 6: PHP APIs and Deployment

Try It Yourself:

This PHP API & Deployment example demonstrates:

PHP API & Deployment Features:

PRACTICE PLAYGROUND

Experiment with PHP concepts

Your PHP Playground: Try Your Own PHP Code

Practice Ideas for Your PHP Playground:

PHP Development Challenges:

Sample Projects to Try:

Advanced PHP Challenges:

Tips & Resources:

Unlock Premium SkillMynte PHP Content

Advanced PHP Courses

PHP Certification

Expert Mentorship

Monthly

Annual Best Value

Lifetime