🚀 PHP Introduction

🎯 Complete Definition

PHP (Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. Created by Rasmus Lerdorf in 1994, PHP runs on the server side, generating dynamic web page content. It's the "P" in the LAMP stack (Linux, Apache, MySQL, PHP).

🔬 Core Characteristics

Server-side: Code executes on the server, producing HTML sent to the client.
Embedded in HTML: PHP tags <?php ?> can be placed anywhere in HTML files.
Dynamic typing: Variables don't need type declarations (type inferred).
Extensive ecosystem: Frameworks (Laravel, Symfony), CMS (WordPress, Drupal), e-commerce (Magento).
Database integration: Native support for MySQL, PostgreSQL, MongoDB via extensions.
Session management: Built-in sessions, cookies for user state.
Cross-platform: Runs on Windows, Linux, macOS, most web servers.

📊 Industry Usage

PHP powers nearly 80% of websites whose server-side language we know, including Facebook (originally), Wikipedia, Slack, Etsy, and Mailchimp. WordPress alone powers over 40% of all websites. PHP 8.x brings JIT compilation, union types, attributes, and massive performance improvements.

<!DOCTYPE html>
<html>
<body>
    <h1>My first PHP page</h1>
    <?php
        echo "Hello, World! 🌍";
        $version = phpversion();
        echo "<br>PHP Version: " . $version;
    ?>
</body>
</html>
    

📊 Basics & Syntax

🎯 Complete Definition

PHP syntax is similar to C and Perl. Scripts start with <?php and end with ?>. Statements end with semicolon. Whitespace is ignored. Comments: // single line, /* */ multi-line. PHP files can contain HTML, CSS, JavaScript alongside PHP.

🏗️ Basic Syntax Rules

PHP tags: <?php ... ?> (short tags <?= ?> for echo).
Echo / Print: Output data. echo can take multiple parameters.
Case sensitivity: Variable names are case-sensitive; functions and keywords are not (but use consistent).
Statements: Must end with ;.
Comments: //, #, /* */.

<?php
    // This is a single-line comment
    # This is also a comment
    /*
        Multi-line comment
    */
    
    // Echo output
    echo "Hello ";
    echo "World", "!";
    
    // Short echo tag (if enabled)
    $name = "PHP";
?>
<p>Learning <?= $name ?> is fun!</p>
    

📦 Variables & Data Types

🎯 Complete Definition

Variables in PHP start with $ and are dynamically typed. PHP supports 8 primitive types: booleans, integers, floats (doubles), strings, arrays, objects, resources, and NULL. Type juggling automatically converts types as needed, but strict typing is possible (declare(strict_types=1)).

🔤 Data Types

string: Series of characters, e.g. "hello", 'world'
int: Whole numbers (32/64-bit, platform dependent)
float: Decimal numbers (double precision)
bool: true or false
array: Ordered maps (can be indexed or associative)
object: Instances of classes
NULL: No value
resource: External resource (file handle, DB connection)

<?php
    $name = "CodeOrbitPro";     // string
    $age = 25;                  // int
    $score = 98.5;              // float
    $active = true;             // bool
    $skills = ["PHP", "MySQL"]; // array
    $nothing = null;            // NULL
    
    echo "$name is $age years old. Active: " . ($active ? 'yes' : 'no');
    
    // Type checking
    var_dump($name);   // string(12) "CodeOrbitPro"
    var_dump($score);  // float(98.5)
    
    // Type juggling
    $total = "10" + 5; // 15 (int)
    $concat = "10" . 5; // "105" (string)
?>
    

🔢 Operators

🎯 Complete Definition

Operators perform operations on variables and values. PHP has arithmetic, assignment, comparison, logical, bitwise, string, array, and type operators. Operator precedence determines evaluation order.

📋 Operator Categories

Arithmetic: +, -, *, /, %, ** (exponentiation)
Assignment: =, +=, -=, *=, /=, .= (string concat)
Comparison: ==, === (identical), !=, <>, !==, <, >, <=, >=, <=> (spaceship)
Logical: and, or, xor, &&, ||, !
String: . (concatenation), .=
Array: + (union), ==, ===, !=, <>
Type: instanceof
Error Control: @ (suppress errors)

<?php
    $a = 10;
    $b = 3;
    
    echo $a + $b;    // 13
    echo $a % $b;    // 1
    echo $a ** $b;   // 1000
    
    // Comparison
    var_dump(5 == "5");   // true (equal value)
    var_dump(5 === "5");  // false (not identical)
    
    // Spaceship
    echo 1 <=> 2;   // -1 (a < b)
    echo 2 <=> 2;   // 0
    echo 3 <=> 2;   // 1
    
    // String concatenation
    $full = "Hello" . " " . "PHP";
    
    // Null coalescing (PHP 7+)
    $username = $_GET['user'] ?? 'guest';
?>
    

🔀 Control Flow

🎯 Complete Definition

Control structures determine execution path: if, else, elseif, switch, match (PHP 8). PHP also supports alternative syntax for templates (using : and endif; etc.).

🏗️ Control Structures

if / elseif / else: Conditional branching.
switch: Multi-way branch (loose comparison).
match: PHP 8+ strict comparison, returns value.
Alternative syntax: if (cond): ... endif; useful in templates.

<?php
    $score = 85;
    
    if ($score >= 90) {
        $grade = 'A';
    } elseif ($score >= 80) {
        $grade = 'B';
    } else {
        $grade = 'C';
    }
    echo "Grade: $grade";
    
    // Switch
    $day = 'Mon';
    switch ($day) {
        case 'Mon':
            echo "Monday!";
            break;
        case 'Tue':
            echo "Tuesday!";
            break;
        default:
            echo "Other day";
    }
    
    // Match (PHP 8)
    $status = 200;
    $message = match ($status) {
        200, 201 => 'OK',
        404 => 'Not Found',
        500 => 'Server Error',
        default => 'Unknown'
    };
    echo $message;
?>
    

🔄 Loops

🎯 Complete Definition

Loops repeat code: while, do-while, for, foreach. break exits loop, continue skips iteration. foreach is ideal for arrays and objects.

🔄 Loop Types

while: Check condition before each iteration.
do-while: Executes at least once, then checks condition.
for: Counter-based loop (init; condition; increment).
foreach: Iterates over arrays/objects: foreach ($array as $key => $value).

<?php
    // while
    $i = 0;
    while ($i < 3) {
        echo $i++;
    }
    
    // for
    for ($j = 0; $j < 3; $j++) {
        echo $j;
    }
    
    // foreach
    $colors = ['red', 'green', 'blue'];
    foreach ($colors as $index => $color) {
        echo "$index: $color ";
    }
    
    // foreach by reference (modify)
    $nums = [1,2,3];
    foreach ($nums as &$num) {
        $num *= 2;
    }
    print_r($nums); // [2,4,6]
    
    // break/continue
    for ($k=0; $k<10; $k++) {
        if ($k % 2 == 0) continue;
        if ($k > 5) break;
        echo $k; // 1,3,5
    }
?>
    

📋 Arrays

🎯 Complete Definition

Arrays are ordered maps (key-value pairs). They can be indexed (0,1,2...) or associative (string keys). PHP arrays are flexible, acting like lists, hash tables, dictionaries, stacks, queues. Array functions provide powerful manipulation.

📊 Array Operations

Indexed: $arr = [1,2,3]; or array(1,2,3);
Associative: $user = ['name' => 'John', 'age' => 30];
Multidimensional: Arrays within arrays.
Common functions: count(), array_push(), array_pop(), array_merge(), array_keys(), in_array(), sort().

<?php
    // Indexed array
    $fruits = ['Apple', 'Banana', 'Cherry'];
    echo $fruits[1]; // Banana
    
    // Associative array
    $person = [
        'first' => 'John',
        'last' => 'Doe',
        'age' => 30
    ];
    echo $person['first']; // John
    
    // Add element
    $fruits[] = 'Orange';   // appends
    
    // Multidimensional
    $matrix = [
        [1,2],
        [3,4]
    ];
    
    // Array functions
    $numbers = [3,1,4,1,5];
    sort($numbers);
    print_r($numbers); // [1,1,3,4,5]
    
    $merged = array_merge($fruits, ['Mango', 'Kiwi']);
    
    // Check key exists
    if (array_key_exists('age', $person)) {
        echo "Age is set";
    }
?>
    

⚙️ Functions

🎯 Complete Definition

Functions encapsulate reusable code. Defined with function name($param) { }. PHP supports type declarations, default values, variadic arguments (...), return type declarations, and strict typing. Functions can be anonymous (closures) and can use variable scope (global, static).

⚙️ Function Features

Parameter types: function add(int $a, int $b): int {}
Default values: function greet($name = "Guest")
Variadic: function sum(...$numbers)
Return type: : ?string (nullable), : void
Strict typing: declare(strict_types=1);
Anonymous functions: $func = function($x) { return $x*2; };
Arrow functions (PHP 7.4+): fn($x) => $x*2

<?php
    declare(strict_types=1);
    
    function square(int $num): int {
        return $num * $num;
    }
    
    function greet(string $name = "World"): string {
        return "Hello, $name!";
    }
    
    function sum(...$nums): float {
        return array_sum($nums);
    }
    
    echo square(5);      // 25
    echo greet("PHP");   // Hello, PHP!
    echo sum(1,2,3,4);   // 10
    
    // Anonymous function
    $multiply = function($a, $b) {
        return $a * $b;
    };
    echo $multiply(3,4); // 12
    
    // Arrow function
    $double = fn($x) => $x * 2;
    echo $double(7);     // 14
?>
    

📝 Strings

🎯 Complete Definition

Strings can be specified in four ways: single quoted, double quoted, heredoc, nowdoc. Double quotes and heredoc interpret variables and escape sequences. Single quotes are literal. PHP has extensive string functions: strlen(), strpos(), substr(), str_replace(), trim(), explode()/implode().

🔤 String Operations

Concatenation: $a . $b
Length: strlen($str) (bytes, not characters for multibyte; use mb_strlen for UTF-8)
Search: strpos($haystack, $needle)
Replace: str_replace($search, $replace, $subject)
Substring: substr($str, $start, $length)
Split/Join: explode($delimiter, $str), implode($glue, $array)
Formatting: printf(), sprintf()

<?php
    $name = "PHP";
    $version = 8;
    
    // Double quotes interpolate
    echo "Learning $name $version is fun!\n";
    
    // Single quotes literal
    echo 'Learning $name $version is fun!\n'; // no interpolation
    
    // Heredoc (like double quotes)
    $text = <<
  

📨 Forms & Superglobals

🎯 Complete Definition

PHP superglobals are built-in variables that are always accessible. For form handling: $_GET (URL parameters), $_POST (form data), $_REQUEST (both). Other superglobals: $_SERVER, $_SESSION, $_COOKIE, $_FILES (uploads), $_ENV. Always sanitize and validate user input!

📨 Common Superglobals

$_GET: Associative array of URL query parameters.
$_POST: Data from HTTP POST method (forms).
$_REQUEST: Combined GET/POST/COOKIE (use with caution).
$_SERVER: Server and execution environment info.
$_FILES: Uploaded files.
$_SESSION / $_COOKIE: Session and cookie data.

<!-- HTML form -->
<form method="POST" action="<?= $_SERVER['PHP_SELF'] ?>">
    Name: <input type="text" name="username">
    <input type="submit" value="Submit">
</form>

<?php
    // Handle form submission
    if ($_SERVER['REQUEST_METHOD'] === 'POST') {
        $name = htmlspecialchars($_POST['username'] ?? '', ENT_QUOTES);
        echo "Hello, $name!";
    }
    
    // GET example: page.php?id=5
    $id = isset($_GET['id']) ? (int)$_GET['id'] : 0;
    echo "ID: $id";
    
    // Server info
    echo "User IP: " . $_SERVER['REMOTE_ADDR'];
    echo "Script: " . $_SERVER['SCRIPT_NAME'];
    
    // File upload (simplified)
    if (isset($_FILES['upload'])) {
        $tmp = $_FILES['upload']['tmp_name'];
        move_uploaded_file($tmp, 'uploads/' . $_FILES['upload']['name']);
    }
?>
    

💾 File Handling

🎯 Complete Definition

File functions allow reading/writing files on the server. Common functions: fopen(), fread(), fwrite(), fclose(), file_get_contents(), file_put_contents(), fgets(), feof(). Check permissions and handle errors.

📁 File Modes

r – read only, pointer at beginning.
w – write only, truncates, creates if not exists.
a – append, creates if not exists.
r+ – read/write, pointer at beginning.
w+ – read/write, truncates.
a+ – read/append.
xb – exclusive create, binary.

<?php
    $filename = "data.txt";
    
    // Write (simple)
    file_put_contents($filename, "Hello, PHP!\n", FILE_APPEND);
    
    // Read (simple)
    $content = file_get_contents($filename);
    echo $content;
    
    // Read line by line
    $handle = fopen($filename, "r");
    if ($handle) {
        while (($line = fgets($handle)) !== false) {
            echo "Line: $line
";
        }
        fclose($handle);
    }
    
    // Write with fopen
    $fp = fopen("newfile.txt", "w");
    fwrite($fp, "First line\n");
    fwrite($fp, "Second line");
    fclose($fp);
    
    // Check existence
    if (file_exists("data.txt")) {
        echo "Filesize: " . filesize("data.txt");
    }
?>
    

🔐 Sessions & Cookies

🎯 Complete Definition

Sessions store user-specific data across pages (server-side). Start with session_start(), then read/write $_SESSION array. Cookies store small data on client side; set with setcookie(), read from $_COOKIE. Sessions are more secure for sensitive data.

🔐 Session & Cookie Functions

session_start() – start or resume session.
$_SESSION['key'] = value; – store data.
session_destroy() – destroy session.
setcookie(name, value, expire, path, domain, secure, httponly)
isset($_COOKIE['name']) – check cookie.
unset($_COOKIE['name']) – remove cookie (by setting past expiry).

<?php
    // Start session (must be before any output)
    session_start();
    
    // Set session variable
    $_SESSION['username'] = 'codeorbit';
    $_SESSION['role'] = 'admin';
    
    // Read session
    if (isset($_SESSION['username'])) {
        echo "Logged in as: " . $_SESSION['username'];
    }
    
    // Destroy session (logout)
    // session_unset();
    // session_destroy();
    
    // Set cookie (expires in 1 hour)
    setcookie('theme', 'dark', time() + 3600, '/');
    
    // Read cookie
    if (isset($_COOKIE['theme'])) {
        echo "Theme: " . $_COOKIE['theme'];
    }
    
    // Delete cookie
    setcookie('theme', '', time() - 3600, '/');
?>
    

🗄️ MySQL & PDO

🎯 Complete Definition

PDO (PHP Data Objects) is a consistent interface for accessing databases. It supports MySQL, PostgreSQL, SQLite, etc. Prepared statements prevent SQL injection. Use new PDO(), then query with prepare(), execute(), fetch().

🗄️ PDO Operations

Connect: $pdo = new PDO($dsn, $user, $pass);
Prepared statement (SELECT): $stmt = $pdo->prepare("SELECT * FROM users WHERE id = ?");
Execute: $stmt->execute([$id]);
Fetch: $row = $stmt->fetch(); (assoc array by default)
Insert/Update/Delete: similar with execute.
Error handling: set error mode to exception: $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

<?php
    try {
        // DSN: mysql:host=localhost;dbname=test;charset=utf8mb4
        $pdo = new PDO('mysql:host=localhost;dbname=test', 'root', '');
        $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        
        // SELECT with named placeholder
        $stmt = $pdo->prepare('SELECT * FROM users WHERE email = :email');
        $stmt->execute(['email' => 'john@example.com']);
        $user = $stmt->fetch(PDO::FETCH_ASSOC);
        
        if ($user) {
            echo "User: " . $user['name'];
        }
        
        // INSERT
        $insert = $pdo->prepare('INSERT INTO users (name, email) VALUES (?, ?)');
        $insert->execute(['Jane Doe', 'jane@example.com']);
        $lastId = $pdo->lastInsertId();
        
        // UPDATE
        $update = $pdo->prepare('UPDATE users SET name = :name WHERE id = :id');
        $update->execute(['name' => 'Jane Smith', 'id' => $lastId]);
        
        // Transaction
        $pdo->beginTransaction();
        // ... queries ...
        $pdo->commit();
        
    } catch (PDOException $e) {
        die("Database error: " . $e->getMessage());
    }
?>
    

🏗️ OOP & Advanced

🎯 Complete Definition

Object-Oriented PHP supports classes, inheritance, interfaces, traits, abstract classes, and more. Visibility: public, protected, private. Magic methods (__construct(), __destruct(), __get(), __set(), __call(), etc.) enable powerful behaviors. Namespaces organize code. Modern PHP (8+) adds union types, attributes, named arguments, constructor property promotion, and match expressions.

🚀 Advanced Features

Constructor property promotion: public function __construct(private string $name) {}
Union types: int|string $value
Named arguments: func(age: 30, name: 'John')
Attributes: #[Route('/api')]
Traits: Reusable code blocks.
Anonymous classes: $obj = new class { ... };
Generators: yield for memory-efficient iteration.

<?php
    namespace App\Models;
    
    use Attribute;
    
    // Attribute (PHP 8)
    #[Attribute]
    class Column {
        public function __construct(public string $name) {}
    }
    
    // Class with constructor promotion
    class User {
        #[Column('user_name')]
        private string $name;
        
        public function __construct(
            private int $id,
            string $name,
            private ?string $email = null
        ) {
            $this->name = $name;
        }
        
        // Method with union type
        public function setId(int|string $id): void {
            $this->id = (int)$id;
        }
        
        public function getName(): string {
            return $this->name;
        }
    }
    
    // Trait
    trait Timestampable {
        private DateTime $createdAt;
        private DateTime $updatedAt;
        
        public function setTimestamps(): void {
            $this->createdAt = new DateTime();
            $this->updatedAt = new DateTime();
        }
    }
    
    class Post {
        use Timestampable;
        // ...
    }
    
    // Usage
    $user = new User(1, 'Alice', 'alice@example.com');
    echo $user->getName(); // Alice
    
    // Named arguments
    $user2 = new User(email: 'bob@example.com', id: 2, name: 'Bob');
    
    // Generator
    function generateNumbers(int $max): Generator {
        for ($i = 1; $i <= $max; $i++) {
            yield $i;
        }
    }
    
    foreach (generateNumbers(3) as $num) {
        echo $num; // 123
    }
?>
    