PHP Best Practices & Next Steps

PHP Best Practices & Next Steps

Congratulations on completing this PHP & MySQL fundamentals course! In this final lesson, we'll cover coding best practices and guide you on your journey to becoming a professional PHP developer.

1. Code Organization and Structure

Well-organized code is easier to maintain, test, and scale.

Follow PSR Standards

PHP Standards Recommendations (PSR) provide coding standards for interoperability.

<?php
// PSR-1: Basic Coding Standard
// - PHP tags: Use <?php ?> or <?= ?>, never short tags
// - Encoding: UTF-8 without BOM
// - Files: Either declare symbols OR have side effects, not both

// PSR-12: Extended Coding Style
namespace App\Controllers;  // Namespace declaration

use App\Models\User;       // Use statements
use App\Services\AuthService;

class UserController         // Class names in PascalCase
{
    private AuthService $authService;  // Properties in camelCase

    public function __construct(AuthService $authService)
    {
        $this->authService = $authService;
    }

    public function login(string $username, string $password): bool  // Methods in camelCase
    {
        // 4 spaces indentation (not tabs)
        if ($this->authService->validate($username, $password)) {
            return true;
        }

        return false;
    }
}
?>

Use Meaningful Names

<?php
// ❌ Bad: Unclear variable names
$d = 30;
$u = getU($id);
function proc($x) { /* ... */ }

// ✅ Good: Descriptive names
$daysUntilExpiry = 30;
$user = getUserById($id);
function processPayment($amount) { /* ... */ }

// ✅ Good: Constants in UPPER_CASE
define('MAX_LOGIN_ATTEMPTS', 5);
const DATABASE_HOST = 'localhost';

// ✅ Good: Boolean variables
$isActive = true;
$hasPermission = false;
$canDelete = checkPermissions($user);
?>

Keep Functions Small and Focused

<?php
// ❌ Bad: Function does too much
function processUser($data) {
    // Validate
    // Save to database
    // Send email
    // Log activity
    // Update cache
    // Return result
}

// ✅ Good: Single Responsibility Principle
function validateUserData(array $data): bool {
    return !empty($data['email']) && !empty($data['password']);
}

function saveUser(array $data): int {
    // Only saves user to database
    $stmt = $pdo->prepare("INSERT INTO users (email, password) VALUES (?, ?)");
    $stmt->execute([$data['email'], $data['password']]);
    return $pdo->lastInsertId();
}

function sendWelcomeEmail(string $email): void {
    // Only sends email
    mail($email, 'Welcome!', 'Thank you for registering');
}

// Compose them together
function registerUser(array $data): bool {
    if (!validateUserData($data)) {
        return false;
    }

    $userId = saveUser($data);
    sendWelcomeEmail($data['email']);
    logActivity('user_registered', $userId);

    return true;
}
?>

2. Error Handling Best Practices

Proper error handling makes debugging easier and applications more robust.

<?php
// Use exceptions for error handling
class ValidationException extends Exception {}
class DatabaseException extends Exception {}

function createUser(array $data): User {
    // Validate
    if (empty($data['email'])) {
        throw new ValidationException('Email is required');
    }

    // Database operation
    try {
        $stmt = $pdo->prepare("INSERT INTO users (email) VALUES (?)");
        $stmt->execute([$data['email']]);
    } catch (PDOException $e) {
        throw new DatabaseException('Failed to create user: ' . $e->getMessage());
    }

    return new User($pdo->lastInsertId(), $data['email']);
}

// Use try-catch at appropriate levels
try {
    $user = createUser($_POST);
    echo "User created successfully";
} catch (ValidationException $e) {
    echo "Validation error: " . $e->getMessage();
} catch (DatabaseException $e) {
    error_log($e->getMessage());
    echo "An error occurred. Please try again.";
} catch (Exception $e) {
    error_log("Unexpected error: " . $e->getMessage());
    echo "An unexpected error occurred.";
}
?>

3. Documentation and Comments

Good documentation helps you and other developers understand the code.

<?php
/**
 * Calculates the total price including tax
 *
 * @param float $price The base price before tax
 * @param float $taxRate The tax rate as a decimal (e.g., 0.15 for 15%)
 * @return float The total price including tax
 * @throws InvalidArgumentException If price or taxRate is negative
 */
function calculateTotalPrice(float $price, float $taxRate): float {
    if ($price < 0 || $taxRate < 0) {
        throw new InvalidArgumentException('Price and tax rate must be positive');
    }

    return $price * (1 + $taxRate);
}

/**
 * User model class
 *
 * Represents a user in the system with authentication capabilities
 */
class User {
    /** @var int User ID */
    private int $id;

    /** @var string User email address */
    private string $email;

    /** @var array User roles */
    private array $roles;

    // Good comments explain WHY, not WHAT
    // ❌ Bad: Obvious comment
    $total = $price + $tax;  // Add price and tax

    // ✅ Good: Explains reasoning
    // We store the hash instead of the password for security
    $passwordHash = password_hash($password, PASSWORD_DEFAULT);

    // ✅ Good: Explains complex logic
    // Use bitwise operation for performance in tight loops
    // This is 10x faster than modulo for powers of 2
    if (($index & ($size - 1)) === 0) {
        // Process every Nth item
    }
}
?>

4. Testing Your Code

Testing ensures your code works correctly and prevents regressions.

Unit Testing with PHPUnit

<?php
// Install PHPUnit: composer require --dev phpunit/phpunit

// tests/UserTest.php
use PHPUnit\Framework\TestCase;

class UserTest extends TestCase {
    public function testUserCreation() {
        $user = new User(1, 'test@example.com');

        $this->assertEquals(1, $user->getId());
        $this->assertEquals('test@example.com', $user->getEmail());
    }

    public function testInvalidEmail() {
        $this->expectException(ValidationException::class);

        new User(1, 'invalid-email');
    }

    public function testPasswordHashing() {
        $password = 'secret123';
        $user = new User(1, 'test@example.com');
        $user->setPassword($password);

        // Password should be hashed
        $this->assertNotEquals($password, $user->getPasswordHash());

        // Verification should work
        $this->assertTrue($user->verifyPassword($password));
    }
}

// Run tests: ./vendor/bin/phpunit tests/
?>

5. Performance Best Practices

Write efficient code that scales well.

<?php
// ✅ Use prepared statements (prevents SQL injection AND improves performance)
$stmt = $pdo->prepare("SELECT * FROM users WHERE id = ?");
foreach ($ids as $id) {
    $stmt->execute([$id]);
    // Process result
}

// ✅ Fetch only needed columns
$stmt = $pdo->query("SELECT id, name FROM users");  // Good
$stmt = $pdo->query("SELECT * FROM users");         // Wasteful if you only need id, name

// ✅ Use appropriate fetch modes
$users = $stmt->fetchAll(PDO::FETCH_ASSOC);  // Returns array
$user = $stmt->fetchObject(User::class);      // Returns object

// ✅ Use indexing for large arrays
$userMap = [];
foreach ($users as $user) {
    $userMap[$user['id']] = $user;  // O(1) lookup instead of O(n)
}

// ✅ Cache expensive operations
function getExpensiveData() {
    static $cache = null;

    if ($cache === null) {
        // Expensive calculation
        $cache = performExpensiveOperation();
    }

    return $cache;
}

// ✅ Use opcode caching (OPcache)
// Enable in php.ini:
// opcache.enable=1
// opcache.memory_consumption=128
// opcache.max_accelerated_files=10000

// ✅ Profile your code
$start = microtime(true);

// Your code here

$duration = microtime(true) - $start;
error_log("Operation took: " . $duration . " seconds");
?>

6. Version Control with Git

Essential for professional development and collaboration.

# Initialize repository
git init
git add .
git commit -m "Initial commit"

# Create .gitignore file
vendor/
node_modules/
.env
*.log
.DS_Store

# Branching workflow
git checkout -b feature/user-authentication
# Make changes
git add .
git commit -m "Add user authentication"
git push origin feature/user-authentication

# Merge to main
git checkout main
git merge feature/user-authentication
git push origin main

# Good commit messages
# ❌ Bad
git commit -m "fixed stuff"
git commit -m "changes"

# ✅ Good
git commit -m "Fix validation bug in user registration form"
git commit -m "Add password reset functionality"
git commit -m "Refactor database connection to use singleton pattern"

7. Modern PHP Frameworks

Frameworks provide structure, security, and productivity boosts.

Popular PHP Frameworks

Getting Started with Laravel

# Install Laravel via Composer
composer create-project laravel/laravel my-project

# Start development server
cd my-project
php artisan serve

# Create a controller
php artisan make:controller UserController

# Create a model with migration
php artisan make:model User -m

# Run migrations
php artisan migrate

# Define routes (routes/web.php)
Route::get('/users', [UserController::class, 'index']);
Route::post('/users', [UserController::class, 'store']);

# Controller example
class UserController extends Controller {
    public function index() {
        $users = User::all();
        return view('users.index', compact('users'));
    }
}

# Eloquent ORM
$users = User::where('active', true)
    ->orderBy('created_at', 'desc')
    ->take(10)
    ->get();

# Blade templates (resources/views/users/index.blade.php)
@foreach ($users as $user)
    <div>{{ $user->name }}</div>
@endforeach

8. Essential Tools and Technologies

• Composer: Dependency management (you've used this!)
• Docker: Containerization for consistent development environments
• Xdebug: Debugging and profiling tool
• PHPStan/Psalm: Static analysis tools to find bugs
• PHP CS Fixer: Automatic code formatting
• Postman/Insomnia: API testing tools

9. Your Learning Roadmap

10. Building Your Portfolio

Projects to demonstrate your skills to potential employers:

11. Community and Resources

• PHP.net: Official documentation (always your first stop)
• Laravel.com: Framework documentation and tutorials
• PHP The Right Way: Best practices guide (phptherightway.com)
• Stack Overflow: Q&A for specific problems
• GitHub: Read code from popular projects
• Laracasts: Video tutorials for Laravel (and PHP in general)
• Reddit r/PHP: PHP community discussions

12. Professional Development Tips

13. Job Market and Career Paths

Final Words

You've completed the PHP & MySQL Fundamentals course and learned:

• PHP syntax, variables, functions, and control structures
• Object-oriented programming with classes and inheritance
• Database design, SQL queries, and PDO for database interaction
• Form handling, file uploads, and session management
• Security best practices to build safe applications
• Modern development practices and tools

Thank You!

Thank you for taking this course. You now have a solid foundation in PHP and MySQL. The rest is up to you - practice, build projects, and never stop learning. Good luck on your journey to becoming a professional PHP developer!

Happy Coding! 🚀