Laravel each() vs foreach() Performance Comparison: Which is Faster?

Introduction

When working with Laravel, developers often encounter situations where they need to iterate through collections or arrays. Two popular methods for this task are Laravel’s each() method and PHP's native foreach() loop. Understanding when and how to use each method can significantly impact your application's performance and code readability.

What is Laravel’s each() Method?

Laravel’s each() method is a collection method that allows you to iterate over each item in a collection while maintaining the fluent interface. It's part of Laravel's Collection class and provides a more functional programming approach to iteration.

$collection->each(function ($item, $key) {
    // Your logic here
});

What is PHP’s foreach() Method?

The foreach() construct is PHP's native way to iterate through arrays and objects. It's been a core part of PHP since version 4 and provides a straightforward approach to loop through data structures.

foreach ($array as $key => $value) {
    // Your logic here
}

Key Differences Between each() and foreach()

1. Return Values

Laravel each() Method:

$users = collect(['John', 'Jane', 'Bob']);

$result = $users->each(function ($user, $index) {
    echo "User {$index}: {$user}\n";
});

// Returns the original collection
// $result still contains ['John', 'Jane', 'Bob']

PHP foreach() Method:

$users = ['John', 'Jane', 'Bob'];

foreach ($users as $index => $user) {
    echo "User {$index}: {$user}\n";
}

// Returns nothing (void)

2. Method Chaining

Laravel each() Method:

$products = collect([
    ['name' => 'Laptop', 'price' => 1000],
    ['name' => 'Phone', 'price' => 500],
    ['name' => 'Tablet', 'price' => 300]
]);

$expensiveProducts = $products
    ->each(function ($product) {
        Log::info("Processing: " . $product['name']);
    })
    ->filter(function ($product) {
        return $product['price'] > 400;
    })
    ->pluck('name');

// Result: ['Laptop', 'Phone']

PHP foreach() Method:

$products = [
    ['name' => 'Laptop', 'price' => 1000],
    ['name' => 'Phone', 'price' => 500],
    ['name' => 'Tablet', 'price' => 300]
];

$expensiveProducts = [];
foreach ($products as $product) {
    Log::info("Processing: " . $product['name']);
    if ($product['price'] > 400) {
        $expensiveProducts[] = $product['name'];
    }
}

3. Early Termination

Laravel each() Method:

$numbers = collect([1, 2, 3, 4, 5]);

$numbers->each(function ($number) {
    if ($number === 3) {
        return false; // Stops iteration
    }
    echo $number . "\n";
});
// Output: 1, 2

PHP foreach() Method:

$numbers = [1, 2, 3, 4, 5];

foreach ($numbers as $number) {
    if ($number === 3) {
        break; // Stops iteration
    }
    echo $number . "\n";
}
// Output: 1, 2

Practical Code Examples

Example: Processing User Data

Using Laravel each():

<?php

namespace App\Http\Controllers;

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

class UserController extends Controller
{
    public function processUsers()
    {
        $users = User::all();
        
        $processedUsers = $users->each(function ($user) {
            // Update last login timestamp
            $user->last_processed_at = now();
            $user->save();
            
            // Send notification
            $user->notify(new AccountProcessedNotification());
        });
        
        return response()->json([
            'message' => 'Users processed successfully',
            'count' => $processedUsers->count()
        ]);
    }
}

Using foreach():

<?php

namespace App\Http\Controllers;

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

class UserController extends Controller
{
    public function processUsers()
    {
        $users = User::all();
        $processedCount = 0;
        
        foreach ($users as $user) {
            // Update last login timestamp
            $user->last_processed_at = now();
            $user->save();
            
            // Send notification
            $user->notify(new AccountProcessedNotification());
            $processedCount++;
        }
        
        return response()->json([
            'message' => 'Users processed successfully',
            'count' => $processedCount
        ]);
    }
}

Performance Comparison

1. Memory Usage

• each(): Maintains the collection object in memory, which can use more memory for large datasets
• foreach(): Generally more memory efficient as it works directly with arrays

2. Execution Speed

// Performance test example
$largeDataset = range(1, 100000);
$collection = collect($largeDataset);

// Test foreach performance
$start = microtime(true);
foreach ($largeDataset as $item) {
    $result = $item * 2;
}
$foreachTime = microtime(true) - $start;

// Test each() performance
$start = microtime(true);
$collection->each(function ($item) {
    $result = $item * 2;
});
$eachTime = microtime(true) - $start;

echo "foreach time: " . $foreachTime . "\n";
echo "each() time: " . $eachTime . "\n";

Benefits of each() Method

1. Fluent Interface

$users = User::where('active', true)
    ->get()
    ->each(function ($user) {
        $user->increment('login_count');
    })
    ->filter(function ($user) {
        return $user->login_count > 10;
    })
    ->values();

2. Consistent API

All Laravel collection methods follow the same pattern, making code more predictable and maintainable.

3. Immutability Support

$originalData = collect([1, 2, 3, 4, 5]);
$processedData = $originalData->each(function ($item) {
    // Process without modifying original
    echo $item * 2;
});
// $originalData remains unchanged

Benefits of foreach() Method

1. Performance

Better performance for simple iterations, especially with large datasets.

2. Memory Efficiency

Lower memory footprint when working with plain arrays.

3. Universal Compatibility

Works with any PHP iterable, not just Laravel collections.

4. Simplicity

// Simple and straightforward
foreach ($items as $item) {
    echo $item;
}

When to Use Each Method

Use Laravel each() When:

• Working with Laravel collections
• Need method chaining
• Want to maintain functional programming style
• Working with Eloquent models
• Need to preserve the collection for further operations

Use foreach() When:

• Performance is critical
• Working with simple arrays
• Memory usage is a concern
• Don’t need method chaining
• Working with large datasets

Conclusion

Both Laravel’s each() method and PHP's foreach() construct have their place in Laravel development. The each() method excels in scenarios requiring method chaining and functional programming patterns, while foreach() offers superior performance for simple iterations and large datasets.

Choose each() when you need the fluent interface and are working with Laravel collections. Opt for foreach() when performance is critical or when working with simple arrays. Understanding these differences will help you write more efficient and maintainable Laravel applications.

If you found this helpful, feel free to share or drop a comment. Happy coding with Laravel! 🧱✨