Implementing the MVC View Layer in PHP: A Practical Guide

Previously in this course, we explored Building the Controller Layer: Managing MVC Requests in PHP, where we centralized request handling and coordinated our models. Now, we need to address the "V" in MVC: the MVC View.

In a robust application, your controller should handle logic—like fetching data from the Model layer—but it should never contain raw HTML strings. Mixing PHP logic with HTML leads to "spaghetti code" that is impossible to maintain. We solve this by offloading presentation to dedicated view files.

The First Principle: Separation of Concerns

The goal of the View layer is simple: take data provided by the controller and render it as HTML. By separating presentation logic, you ensure that designers can edit HTML without touching your business logic, and developers can refactor database queries without breaking the UI.

In PHP, we achieve this by using the include or require statements. When you include a file, it executes in the scope of the calling file. This means any variables defined in your controller become available inside the view file automatically.

Worked Example: Creating a View Template

Let's assume we have a ProductController that fetches a list of items and needs to display them.

1. The View File (views/product_list.php)

Create a simple file that expects a $products array to be available in its scope.

PHP
<!-- views/product_list.php -->
<h1>Product Catalog</h1>
<ul>
    <?php foreach ($products as $product): ?>
        <li><?= htmlspecialchars($product['name']) ?> - $<?= $product['price'] ?></li>
    <?php endforeach; ?>
</ul>

2. The Controller Integration

In your controller, you prepare the data and then include the view file.

PHP
#6A9955">// controllers/ProductController.php
class ProductController {
    public function index() {
        #6A9955">// Imagine this data came from your Model
        $products = [
            ['name' => 'Laptop', 'price' => 999],
            ['name' => 'Mouse', 'price' => 25]
        ];

        #6A9955">// This variable is now available in views/product_list.php
        require 'views/product_list.php';
    }
}

Why this works

When require is called inside the index() method, the product_list.php file is "injected" into that scope. It behaves as if the code inside the view file was written directly inside the index() method. This is the simplest, most performant way to implement an MVC View in raw PHP without overhead.

Hands-on Exercise

1. Create a folder named views in your project root.
2. Inside views, create a file named profile.php.
3. Add HTML to profile.php that displays a user's name and email using variables $name and $email.
4. Write a controller method that defines these variables and requires your profile.php file to render the page.
5. Challenge: Wrap the variable output in htmlspecialchars() to prevent XSS (Cross-Site Scripting) attacks, a critical security practice when rendering user data.

Common Pitfalls

• Logic in Views: Avoid performing database queries or complex calculations inside your view files. The view should only handle formatting and echoing data. If you find yourself writing SELECT * FROM... in a .php view file, move that code to your Model immediately.
• Missing Variables: If your view expects a variable that wasn't defined in the controller, PHP will throw a "Notice: Undefined variable". Always ensure your controller initializes all data the view expects.
• Hardcoded Paths: Avoid using relative paths like ../views/file.php if your project grows complex. Use absolute paths or a constant (like ROOT_PATH) to ensure your require statements don't break when you move files between directories.

FAQ

Q: Should I use a template engine like Twig? A: Template engines provide features like template inheritance and automatic escaping. While they are great for large projects, learning to use native PHP as a template engine first is vital for understanding how the server-side execution flow actually works.

Q: How do I pass a lot of data to a view? A: Instead of creating dozens of individual variables, pass a single associative array (e.g., $data) to your view. This keeps the global scope clean and makes your code more predictable.

Recap

We’ve successfully moved the presentation out of the controller and into dedicated files. By using require within our controller methods, we create a clean separation of concerns, ensuring our views remain purely about display while our controllers handle the heavy lifting.

Up next, we will implement the Front Controller Pattern, which will allow us to route all incoming requests through a single entry point, cleaning up our URL structure significantly.