Best Practices

🏗️ PHP Best Practices: Building Code Like a Master Architect

Imagine you’re building the most amazing LEGO castle ever. You want it to look great, stand strong, and be easy to fix or add new towers later. PHP best practices are like the secret rules that make your code castle perfect!

🎯 The Big Picture

Think of writing code like building with blocks. Best practices are the smart rules that help you:

• Build things that don’t fall apart
• Let others help you build
• Add new rooms easily
• Find and fix problems fast

Let’s explore five super important rules!

📏 Coding Standards: Speaking the Same Language

What Are They?

Imagine if everyone in your class wrote differently—some used GIANT letters, some wrote backwards, some used weird spacing. Reading would be a nightmare!

Coding standards are like handwriting rules for programmers. Everyone writes code the same way, so everyone can read it easily.

The Golden Rules

<?php
// ✅ GOOD: Clear class name
class ShoppingCart
{
    private $items = [];

    public function addItem($product)
    {
        $this->items[] = $product;
    }
}

// ❌ BAD: Messy and confusing
class shoppingcart{
private $items=[];
public function additem($product){
$this->items[]=$product;}}

PSR Standards (The Official Rulebook)

PHP has official rules called PSR (PHP Standards Recommendations):

Simple Tips

1. Use clear names: calculateTotal() not ct()
2. One thing per line: Don’t squish code together
3. Add spaces: Makes reading easier
4. Be consistent: Pick a style, stick with it

🎯 Remember: Good code reads like a story, not a puzzle!

💉 Dependency Injection: Passing the Toys

What Is It?

Imagine you have a toy robot that needs batteries. There are two ways to give it power:

Bad way: The robot goes to the store, finds batteries, and puts them in itself.

Good way: You hand the robot the batteries it needs.

Dependency Injection is the good way! Instead of objects finding what they need, you give them what they need.

Without Injection (The Bad Way)

<?php
class Robot
{
    private $battery;

    public function __construct()
    {
        // Robot finds its own battery 😟
        $this->battery = new Battery();
    }
}

With Injection (The Good Way)

<?php
class Robot
{
    private $battery;

    public function __construct(Battery $battery)
    {
        // You give the robot a battery 😊
        $this->battery = $battery;
    }
}

// Now you control what battery to use!
$superBattery = new SuperBattery();
$robot = new Robot($superBattery);

Why This Is Amazing

graph TD
    A["You Control Everything"] --> B["Easy to Test"]
    A --> C["Easy to Change"]
    A --> D["Easy to Understand"]
    B --> E["Reliable Code"]
    C --> E
    D --> E

Three Ways to Inject

1. Constructor: Pass when creating object
2. Setter: Use a special method
3. Interface: Define what’s needed

🧱 SOLID Principles: The Five Superpowers

SOLID is like having five superpowers for your code. Each letter is a power!

S — Single Responsibility

One job per class. Like how a toaster only toasts and a blender only blends.

<?php
// ✅ GOOD: One job each
class OrderCalculator
{
    public function calculateTotal($items) { }
}

class OrderEmailer
{
    public function sendConfirmation($order) { }
}

// ❌ BAD: Too many jobs
class Order
{
    public function calculate() { }
    public function sendEmail() { }
    public function saveToDatabase() { }
    public function generatePDF() { }
}

O — Open/Closed

Open for adding, closed for changing. Like adding new LEGO pieces without breaking old ones.

<?php
interface PaymentMethod
{
    public function pay($amount);
}

class CreditCard implements PaymentMethod
{
    public function pay($amount) { }
}

// Add new payment without changing old code!
class PayPal implements PaymentMethod
{
    public function pay($amount) { }
}

L — Liskov Substitution

Kids should work like parents. If a class extends another, it should work the same way.

<?php
class Bird
{
    public function move() { return "flying"; }
}

class Penguin extends Bird
{
    // ✅ Still moves, just differently
    public function move() { return "swimming"; }
}

I — Interface Segregation

Don’t force unused features. Like a remote control with only the buttons you need.

<?php
// ✅ GOOD: Small, focused interfaces
interface Walkable
{
    public function walk();
}

interface Swimmable
{
    public function swim();
}

class Duck implements Walkable, Swimmable
{
    public function walk() { }
    public function swim() { }
}

D — Dependency Inversion

Depend on contracts, not details. Like plugging any USB device into a USB port.

<?php
// Depend on the interface, not the class
interface LoggerInterface
{
    public function log($message);
}

class App
{
    private $logger;

    public function __construct(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }
}

🎨 Design Patterns: Proven Recipes

Design patterns are like cooking recipes. Smart programmers figured out the best ways to solve common problems!

Factory Pattern: The Object Maker

Like a pizza shop that makes different pizzas on demand.

<?php
class AnimalFactory
{
    public static function create($type)
    {
        return match($type) {
            'dog' => new Dog(),
            'cat' => new Cat(),
            'bird' => new Bird(),
        };
    }
}

$pet = AnimalFactory::create('dog');

Singleton Pattern: The Only One

Like there’s only one sun in our solar system.

<?php
class Database
{
    private static $instance = null;

    public static function getInstance()
    {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }
}

Observer Pattern: The Notification System

Like subscribing to a YouTube channel—you get notified of new videos.

<?php
class Newsletter
{
    private $subscribers = [];

    public function subscribe($email)
    {
        $this->subscribers[] = $email;
    }

    public function notify($message)
    {
        foreach ($this->subscribers as $sub) {
            // Send to each subscriber
        }
    }
}

Strategy Pattern: The Switchable Brain

Like choosing different routes to school based on weather.

graph TD
    A["Payment System"] --> B{Choose Strategy}
    B --> C["Credit Card"]
    B --> D["PayPal"]
    B --> E["Crypto"]

⛓️ Method Chaining: The Smooth Flow

What Is It?

Method chaining is like a water slide—you keep going from one thing to the next without stopping!

Instead of:

<?php
$query = new Query();
$query->select('name');
$query->from('users');
$query->where('active', true);
$result = $query->get();

You can write:

<?php
$result = (new Query())
    ->select('name')
    ->from('users')
    ->where('active', true)
    ->get();

How It Works

The secret? Return $this at the end of each method!

<?php
class Sandwich
{
    private $ingredients = [];

    public function addBread()
    {
        $this->ingredients[] = 'bread';
        return $this; // The magic!
    }

    public function addCheese()
    {
        $this->ingredients[] = 'cheese';
        return $this;
    }

    public function addLettuce()
    {
        $this->ingredients[] = 'lettuce';
        return $this;
    }

    public function build()
    {
        return implode(' + ', $this->ingredients);
    }
}

// Build a sandwich smoothly!
$lunch = (new Sandwich())
    ->addBread()
    ->addCheese()
    ->addLettuce()
    ->build();
// Result: "bread + cheese + lettuce"

Real World Example: Query Builder

<?php
$users = DB::table('users')
    ->where('age', '>', 18)
    ->orderBy('name')
    ->limit(10)
    ->get();

Benefits of Chaining

🎉 Bringing It All Together

Here’s how these practices work as a team:

graph TD
    A["Coding Standards"] --> F["Clean Code"]
    B["Dependency Injection"] --> F
    C["SOLID Principles"] --> F
    D["Design Patterns"] --> F
    E["Method Chaining"] --> F
    F --> G["Happy Developers"]
    F --> H["Reliable Apps"]
    F --> I["Easy Maintenance"]

Your Code Checklist

• [ ] Is my code easy to read? (Coding Standards)
• [ ] Am I passing dependencies in? (Dependency Injection)
• [ ] Does each class have one job? (SOLID - S)
• [ ] Can I add features without breaking things? (SOLID - O)
• [ ] Am I using proven solutions? (Design Patterns)
• [ ] Is my code flowing smoothly? (Method Chaining)

🚀 You Did It!

You now know the secrets of PHP best practices! These aren’t just rules—they’re tools that make you a coding superhero.

Remember:

• 📏 Standards = Everyone speaks the same language
• 💉 Injection = Give objects what they need
• 🧱 SOLID = Five superpowers for clean code
• 🎨 Patterns = Proven recipes for success
• ⛓️ Chaining = Smooth, flowing code

Now go build something amazing! 🏗️