Namespaces and Autoloading

🏠 PHP Namespaces & Autoloading: Organizing Your Code Kingdom

Imagine you’re building a huge LEGO city. Without labels on your storage boxes, finding the right pieces becomes a nightmare!

🎯 The Big Picture

Namespaces are like street addresses for your PHP code. Autoloading is like having a magic delivery service that brings you any piece you need, exactly when you need it.

Together, they transform messy code into a beautiful, organized kingdom!

📍 What Are Namespaces?

The Problem: Name Collisions

Imagine two kids in class both named “Alex.” When the teacher calls “Alex!” — who answers?

// file1.php
class User { } // Alex #1

// file2.php
class User { } // Alex #2

// CRASH! PHP gets confused!

The Solution: Namespaces

Give each “Alex” a last name!

// file1.php
namespace App\Models;
class User { } // Alex Smith

// file2.php
namespace Admin\Core;
class User { } // Alex Johnson

// Now PHP knows exactly who's who!

How to Declare a Namespace

<?php
namespace MyApp\Helpers;

class Calculator {
    public function add($a, $b) {
        return $a + $b;
    }
}

Key Rules:

• namespace must be the FIRST code in your file
• Only declare statements can come before it
• Use backslash \ to separate levels

🔑 Using Namespaces

Method 1: Full Path (Like GPS Coordinates)

<?php
// Using the full "address"
$calc = new \MyApp\Helpers\Calculator();
$result = $calc->add(5, 3);

Method 2: Import with use (Like Saving a Contact)

<?php
use MyApp\Helpers\Calculator;

// Now just use the short name!
$calc = new Calculator();
$result = $calc->add(5, 3);

Importing Multiple Classes

<?php
use MyApp\Models\User;
use MyApp\Models\Product;
use MyApp\Helpers\Calculator;

$user = new User();
$product = new Product();
$calc = new Calculator();

✨ Namespace Aliasing

The Problem: Two Classes, Same Name!

use App\Models\User;
use Admin\Models\User; // CONFLICT!

The Solution: Give Them Nicknames!

use App\Models\User as AppUser;
use Admin\Models\User as AdminUser;

$customer = new AppUser();
$manager = new AdminUser();

Real World Example

<?php
use DateTime as PHPDate;
use Carbon\Carbon as CarbonDate;

$phpDate = new PHPDate();
$carbonDate = new CarbonDate();

echo $phpDate->format('Y-m-d');
echo $carbonDate->toDateString();

Aliasing is like giving friends nicknames so you don’t confuse them!

🚚 Autoloading Classes

The Old Way (Painful!)

<?php
// Manually including every file 😫
require 'src/Models/User.php';
require 'src/Models/Product.php';
require 'src/Helpers/Calculator.php';
require 'src/Services/PaymentService.php';
// 50 more lines...

The Magic Way: Autoloading!

<?php
// Tell PHP how to find classes
spl_autoload_register(function($class) {
    $path = str_replace('\\', '/', $class);
    include "src/{$path}.php";
});

// PHP automatically loads what you need!
$user = new App\Models\User();

How It Works

graph TD
    A["You write: new User"] --> B{Is User loaded?}
    B -->|No| C["Autoloader kicks in"]
    C --> D["Finds User.php"]
    D --> E["Includes the file"]
    E --> F["Creates User object"]
    B -->|Yes| F

It’s like a butler who fetches any book from your library the moment you mention its name!

📦 Composer Basics

What is Composer?

Composer is PHP’s package manager — like an app store for PHP code!

Instead of writing everything yourself, you can install pre-made solutions:

# Install a package
composer require monolog/monolog

# Install all project dependencies
composer install

# Update packages
composer update

The composer.json File

{
    "name": "myapp/project",
    "require": {
        "monolog/monolog": "^3.0",
        "guzzlehttp/guzzle": "^7.0"
    },
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

Using Composer’s Autoloader

<?php
// This ONE line loads EVERYTHING!
require 'vendor/autoload.php';

// Now use any class from any package
use Monolog\Logger;
use App\Models\User;

$log = new Logger('app');
$user = new User();

Composer is like having a personal assistant who:

• Downloads tools you need 📥
• Keeps them updated 🔄
• Loads them automatically 🚀

🎯 PSR-4 Autoloading

What is PSR-4?

PSR-4 is a standard recipe for organizing files.

The rule is simple: Namespace = Folder Path

The Formula

Namespace:  App\Models\User
File Path:  src/Models/User.php

Visual Mapping

project/
├── src/
│   ├── Models/
│   │   ├── User.php      → App\Models\User
│   │   └── Product.php   → App\Models\Product
│   ├── Helpers/
│   │   └── Calculator.php → App\Helpers\Calculator
│   └── Services/
│       └── PaymentService.php → App\Services\PaymentService
└── composer.json

Setting Up PSR-4

Step 1: Configure composer.json

{
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

Step 2: Regenerate autoloader

composer dump-autoload

Step 3: Include and use!

<?php
require 'vendor/autoload.php';

use App\Models\User;
use App\Helpers\Calculator;

$user = new User();
$calc = new Calculator();

Multiple Namespace Roots

{
    "autoload": {
        "psr-4": {
            "App\\": "src/",
            "Tests\\": "tests/",
            "Database\\": "database/"
        }
    }
}

🧩 Complete Example

Project Structure

my-project/
├── composer.json
├── public/
│   └── index.php
├── src/
│   ├── Models/
│   │   └── User.php
│   └── Services/
│       └── AuthService.php
└── vendor/
    └── autoload.php

composer.json

{
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

src/Models/User.php

<?php
namespace App\Models;

class User {
    public string $name;

    public function greet(): string {
        return "Hello, {$this->name}!";
    }
}

src/Services/AuthService.php

<?php
namespace App\Services;

use App\Models\User;

class AuthService {
    public function login(User $user): bool {
        return true;
    }
}

public/index.php

<?php
require '../vendor/autoload.php';

use App\Models\User;
use App\Services\AuthService;

$user = new User();
$user->name = "Sarah";

$auth = new AuthService();
$auth->login($user);

echo $user->greet();
// Output: Hello, Sarah!

🎉 Summary: Your New Superpowers!

🚀 You Did It!

You now understand how professional PHP projects stay organized!

Remember:

• Namespaces = Street addresses 📍
• Autoloading = Magic delivery 🚚
• Composer = Personal assistant 🤖
• PSR-4 = The golden rule 📏

Go forth and build amazing, organized code! 🎯