Displaying Courses and Categories in Laravel: A Guide

To display courses and their categories in Laravel, you must define a one-to-many relationship between your Course and Category models. This allows you to eager load the associated data efficiently using Eloquent, ensuring that each course record includes its specific category details without triggering additional database queries during rendering.

Defining the Database Schema

Before writing any PHP code, your database structure must support the relationship. You need two primary tables: categories and courses. The categories table typically holds basic information like an ID, name, and timestamps. The courses table must include a foreign key column, usually named category_id, which links each course to its parent category. When creating your migration for the courses table, ensure you add the foreign key constraint. This maintains referential integrity, preventing orphaned records if a category is deleted. A standard migration snippet looks like this:

Schema::create('courses', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->text('description')->nullable();
    $table->foreignId('category_id')->constrained()->onDelete('cascade');
    $table->timestamps();
});

The constrained() method automatically references the categories table, while onDelete('cascade') ensures that deleting a category removes all associated courses. This setup is critical for maintaining clean data as your catalog grows.

Setting Up Eloquent Relationships

Laravel's Eloquent ORM makes querying related data intuitive. You need to update both the Category and Course model classes to reflect the database structure. In the Category model, you define a hasMany relationship because one category can contain multiple courses. Conversely, the Course model defines a belongsTo relationship since each course belongs to exactly one category. Update your app/Models/Category.php file:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Category extends Model
{
    public function courses()
    {
        return $this->hasMany(Course::class);
    }
}

Then, update your app/Models/Course.php file:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Course extends Model
{
    public function category()
    {
        return $this->belongsTo(Category::class);
    }
}

By defining these methods, you enable Laravel to automatically resolve relationships when you access them via properties. For instance, calling $course->category will automatically fetch the related category object from the database.

Fetching Data with Eager Loading

A common performance pitfall in web development is the N+1 query problem. If you loop through a list of courses in your view and access $course->category->name inside the loop, Laravel will execute a separate database query for every single course. To avoid this, use eager loading. In your controller, retrieve the courses using the with method. This instructs Eloquent to fetch the related categories in a single additional query rather than thousands of individual ones.

namespace App\Http\Controllers;

use App\Models\Course;
use Illuminate\Http\Request;

class CourseController extends Controller
{
    public function index()
    {
        // Eager load the 'category' relationship
        $courses = Course::with('category')->get();

        return view('courses.index', compact('courses'));
    }
}

If you are displaying courses grouped by category, it might be more efficient to query categories instead and load their courses:

$categories = Category::with('courses')->get();

This approach reduces the number of HTTP responses and database hits significantly, leading to faster page loads. For deeper insights into handling complex relationships in Laravel, consider reading Implementing Best Relationships for Product Attributes in Laravel PHP, which covers similar structural patterns.

Rendering the View

Once the data reaches your Blade template, you can iterate over the collection to display the information. Because we used eager loading, accessing the category name does not trigger new queries. Here is a simple example of how to render a list of courses in resources/views/courses/index.blade.php:

@foreach($courses as $course)
    

        
{{ $course->title }}
        
Category: {{ $course->category->name ?? 'Uncategorized' }}
        
{{ Str::limit($course->description, 100) }}
    
@endforeach

Always handle cases where the category might be null by using the null coalescing operator (??). This prevents errors if a course exists without an assigned category due to legacy data or migration issues. Using Str::limit helps keep your UI clean by truncating long descriptions.

Handling Errors and Debugging

If you encounter a BadMethodCallException when trying to access a relationship, it usually means the method name in your model does not match what you are calling in the view, or the relationship is not defined correctly. Ensure the method names in your models exactly match the relationship definitions. For example, if you call $course->category in the view, the method in the model must be named category, not cat or getCategoryAttribute unless you are using accessor casting properly. Another common issue is forgetting to import the model namespace in your controller. Always verify that your use statements at the top of the controller file correctly point to App\Models\Course and App\Models\Category. If you are seeing undefined method errors, check the official Laravel documentation or resources like Fixing BadMethodCallException for troubleshooting steps related to model methods.

Frequently Asked Questions

How do I filter courses by a specific category?

You can filter courses by adding a whereHas clause to your query builder. This checks if the related category matches your criteria before fetching the courses. For example, Course::with('category')->whereHas('category', function ($query) { $query->where('name', 'Web Development'); })->get() returns only courses in that specific category.

What happens if a course has no category assigned?

If the foreign key is nullable, the relationship will return null. In your Blade view, you should always use the null coalescing operator (??) to provide a fallback value, such as 'Uncategorized'. This prevents your application from throwing a "Trying to get property of non-object" error when attempting to access properties on a null relationship.

Can I nest categories within categories?

Yes, by defining a self-referencing relationship in your Category model. You would create a parent_id foreign key in the categories table and define a hasMany relationship pointing back to itself. This allows you to build hierarchical structures like Main Category > Sub Category > Sub-Sub Category.

Is eager loading necessary for small datasets?

While eager loading might not cause visible performance issues with ten items, it becomes critical as your dataset grows. Even with small datasets, best practices dictate using eager loading to prevent accidental N+1 problems when you later add pagination or filters. It keeps your code consistent and scalable from day one.

How do I display categories with their course counts?

You can use the withCount method alongside with to retrieve the count of related courses. For example, Category::with(['courses' => function ($query) { $query->latest(); }])->withCount('courses')->get() gives you the category data along with a courses_count attribute you can display directly in your view.