DEV Community: Moolchand Sharma

Laravel 12 + PHP 8.4 Clean Code: Real-World Refactoring Examples Every Developer Should Know

Moolchand Sharma — Thu, 29 May 2025 17:42:04 +0000

Clean Code in Laravel 12: Stop Writing Ugly PHP and Start Using These Real-Life Fixes

Your code works — but does it spark joy?

Laravel 12 and PHP 8.4 give us so many tools to write elegant, expressive code. Yet most devs still write spaghetti Laravel controllers, bulky foreach blocks, and forget about value objects or modern PHP features.

Let’s fix that.

In this guide, I’ll show messy vs. clean code side by side using Laravel 12 + PHP 8.4. These are things every Laravel dev has done — and how to do them better.

🧱 Example 1: Validating and Creating a Model in Controller

😵 Messy Code

public function store(Request $request)
{
    $request->validate([
        'name' => 'required|string|max:255',
        'email' => 'required|email|unique:users,email',
        'password' => 'required|string|min:8',
    ]);
    $user = new User();
    $user->name = $request->name;
    $user->email = $request->email;
    $user->password = Hash::make($request->password);
    $user->save();
    return response()->json($user);
}

✅ Clean Code (Laravel 12 + Form Request + Constructor Promotion)

// app/Http/Requests/StoreUserRequest.php
class StoreUserRequest extends FormRequest
{
    public function rules(): array
    {
        return [
            'name' => 'required|string|max:255',
            'email' => 'required|email|unique:users,email',
            'password' => 'required|string|min:8',
        ];
    }

    public function authorize(): bool
    {
        return true;
    }
}

// app/Services/UserService.php
class UserService
{
    public function __construct(
        protected User $user
    ) {}

  public function create(array $data): User
    {
        return $this->user->create([
            ...Arr::except($data, 'password'),
            'password' => Hash::make($data['password']),
        ]);
    }
}

// Controller
public function store(StoreUserRequest $request, UserService $service)
{
    return response()->json(
        $service->create($request->validated())
    );
}

🧱 Example 2: Filtering with if/foreach Soup

😵 Messy Code

$activeUsers = [];

foreach ($users as $user) {
    if ($user->is_active) {
        $activeUsers[] = $user;
    }
}

✅ Clean Code (Using Collection Pipeline)

$activeUsers = collect($users)->filter->is_active;

Or if you’re working with Eloquent:

$activeUsers = User::where('is_active', true)->get();

Laravel collections + Eloquent FTW.

🧱 Example 3: Boolean Checks in Views

😵 Messy Blade

@if($user->is_admin)
    <span class="badge bg-success">Admin</span>
@else
    <span class="badge bg-secondary">User</span>
@endif

✅ Clean Blade with Component or Enum

Use PHP 8.1+ enums for roles:

enum Role: string {
    case Admin = 'admin';
    case User = 'user';
}

And in Blade:

<x-badge :type="$user->role === Role::Admin ? 'success' : 'secondary'">
    {{ $user->role->name }}
</x-badge>

🧱 Example 4: Date Formatting Repeated Everywhere

😵 Messy Code

{{ \Carbon\Carbon::parse($user->created_at)->format('d M, Y') }}

✅ Clean Code with Accessor

// In User.php model
protected function createdAt(): Attribute
{
    return Attribute::make(
        get: fn($value) => \Carbon\Carbon::parse($value)->format('d M, Y'),
    );
}

Now in Blade:

{{ $user->created_at }}

Beautifully clean.

🧱 Example 5: Deep Nested Conditionals

😵 Messy Code

if ($user) {
    if ($user->is_active) {
        if (!$user->is_banned) {
            // do something
        }
    }
}

✅ Clean Code with Early Returns

if (!$user || !$user->is_active || $user->is_banned) {
    return;
}

// do something

Even better:

if ($user?->is_active && !$user->is_banned) {
    // do something
}

Laravel 12 + PHP 8.4 makes this easier with nullsafe and match expressions.

⚡ Bonus Tips: Laravel 12 + PHP 8.4 Goodies

✅ Read-only classes for DTOs:

readonly class CreateUserData {
    public function __construct(
        public string $name,
        public string $email,
        public string $password
    ) {}
}

✅ Match expressions over switch:

return match($status) {
    'active' => 'Active',
    'inactive' => 'Inactive',
    'banned' => 'Banned',
};

✅ Invokable Actions:

class SendWelcomeEmail {
    public function __invoke(User $user) { ... }
}

app(SendWelcomeEmail::class)($user);

✅ Higher-order pipelines:

$users = User::query()
    ->when($isAdmin, fn($q) => $q->where('role', 'admin'))
    ->get();

🧠 Final Thoughts

Just because your code works, doesn’t mean it’s good.

Clean code in Laravel 12 + PHP 8.4 is:

✨ Expressive
🧪 Testable
🧼 Maintainable
🚀 Scalable

If you liked this, share it or drop a comment!

Want a part 2 with clean test cases or API resource patterns? Just say the word.

Top 10 Laravel 12 Tips for Full-Stack Developers in 2025

Moolchand Sharma — Sun, 25 May 2025 13:39:29 +0000

Master Laravel 12 with these 10 must-know tips for full-stack developers in 2025. Improve code quality, boost app performance, and stay updated with the latest best practices. Perfect for Laravel beginners and pros.

🔹 1. Use Route Resource Shorthands & Grouping

Laravel’s routing system is elegant and expressive.

Instead of defining each route manually:

Route::resource('posts', PostController::class);

Need fewer actions?

Route::resource('posts', PostController::class)->only(['index', 'store']);

For grouped routes:

Route::prefix('v1')->middleware('auth:sanctum')->group(function () {
    Route::apiResource('projects', ProjectController::class);
});

Or reduce repetition with the new controller grouping:

Route::controller(OrderController::class)->group(function () {
    Route::get('orders', 'index');
    Route::post('orders', 'store');
});

🔹 2. Chain Jobs for Multi-Step Background Tasks

Laravel’s queue system is powerful and simple. When a task involves multiple steps, use Bus::chain():

use App\Jobs\{GenerateInvoice, SendInvoiceEmail, ArchiveInvoice};

Bus::chain([
    new GenerateInvoice($order),
    new SendInvoiceEmail($order->user),
    new ArchiveInvoice($order),
])->dispatch();

Perfect for post-purchase flows, reporting, or multi-stage processing.

🔹 3. Use Invokable Controllers for One-Off Actions

Single-purpose controllers? Use invokable syntax:

php artisan make:controller SendWelcomeEmail --invokable

Route it directly:

Route::post('/welcome', SendWelcomeEmail::class);

This is ideal for small, isolated actions like webhooks, emails, or job dispatching.

🔹 4. Use API Resources for Consistent Responses

For cleaner API responses:

return new UserResource($user);

Inside UserResource, you can conditionally expose fields:

public function toArray($request)
{
    return [
        'id' => $this->id,
        'name' => $this->name,
        'email' => $this->when($request->user()->isAdmin(), $this->email),
    ];
}

Great for separating business logic from presentation.

🔹 5. Use Modern Accessors & Mutators in Laravel 12

Laravel 12 recommends using the new closure-style syntax.

Accessor:

use Illuminate\Database\Eloquent\Casts\Attribute;

protected function fullName(): Attribute
{
    return Attribute::make(
        get: fn () => "{$this->first_name} {$this->last_name}",
    );
}

Mutator:

protected function password(): Attribute
{
    return Attribute::make(
        set: fn ($value) => bcrypt($value),
    );
}

No need to use old getXAttribute()/setXAttribute() syntax anymore!

🔹 6. Automate Recurring Tasks with Laravel Scheduling

Forget OS-level cron files — Laravel handles this for you.

$schedule->command('orders:clean')->dailyAt('02:00');

Set up one cron job:

* * * * * php /path-to-your-project/artisan schedule:run >> /dev/null 2>&1

Bonus: Add withoutOverlapping() or onOneServer() for safe multi-server use.

🔹 7. Use Blade Components for Reusable UI

Blade components make your frontend DRY and beautiful.

Create an alert component:

<!-- resources/views/components/alert.blade.php -->
<div class="alert alert-{{ $type }}">
    {{ $slot }}
</div>

Use it like this:

<x-alert type="success">
    Profile updated successfully.
</x-alert>

Also supports nested slots, conditionals, and dynamic components.

🔹 8. Use Casts to Simplify Model Data

Define simple casts:

protected $casts = [
    'is_active' => 'boolean',
    'settings' => 'array',
    'birthday' => 'date:Y-m-d',
];

Create custom casts for advanced logic:

php artisan make:cast JsonCleaner

Then use it:

protected $casts = [
    'metadata' => JsonCleaner::class,
];

Cleaner than manually calling json_decode() everywhere.

🔹 9. Format Code Automatically with Laravel Pint

Keep your codebase consistent and pretty with Pint:

composer require laravel/pint --dev
vendor/bin/pint

Add Pint to your composer.json scripts or CI workflow.

🔹 10. Supercharge Performance with Laravel Octane

Laravel Octane boosts app speed using Swoole or RoadRunner:

composer require laravel/octane
php artisan octane:install
php artisan octane:start

Expect faster response times, persistent workers, and lower CPU usage.

🎯 Final Thoughts

Laravel 12 is the most polished version of the framework yet — but only if you’re using it right. With these 10 tips, you can write elegant, maintainable, and production-ready Laravel apps that scale.

Whether you’re a solo dev, building a SaaS, or freelancing full-time — these practices will make your development smoother and your apps faster.

Enjoyed this article?

👉 Follow me for more Laravel and full-stack dev content

💬 Comment your favourite Laravel tip — I might include it in a future post!