PHP Closures and Anonymous Functions - Advanced Function Concepts

Introduction to Closures and Anonymous Functions

PHP closures and anonymous functions provide powerful ways to create functions dynamically, implement callbacks, and capture variables from the surrounding scope. They are essential for modern PHP programming patterns.

Anonymous Functions

Basic Anonymous Functions

Anonymous functions, also known as lambda functions, are functions without a declared name. They are often used as callback parameters or assigned to variables.

<?php
// Basic anonymous function
$greet = function($name) {
    return "Hello, $name!";
};

echo $greet("John"); // Hello, John!

// Anonymous function as callback
$numbers = [1, 2, 3, 4, 5];

$squared = array_map(function($n) {
    return $n * $n;
}, $numbers);

print_r($squared); // [1, 4, 9, 16, 25]

// Filtering with anonymous functions
$evenNumbers = array_filter($numbers, function($n) {
    return $n % 2 === 0;
});

print_r($evenNumbers); // [2, 4]
?>

Function Parameters and Return Types

<?php
// Anonymous function with type declarations
$calculator = function(int $a, int $b): int {
    return $a + $b;
};

echo $calculator(5, 3); // 8

// Anonymous function with default parameters
$greetWithTime = function($name, $timeOfDay = 'day') {
    return "Good $timeOfDay, $name!";
};

echo $greetWithTime("Alice"); // Good day, Alice!
echo $greetWithTime("Bob", "morning"); // Good morning, Bob!

// Variadic anonymous functions
$sum = function(...$numbers) {
    return array_sum($numbers);
};

echo $sum(1, 2, 3, 4, 5); // 15
?>

Closures and Variable Binding

The `use` Statement

Closures can capture variables from the parent scope using the use statement. This creates a true closure that "closes over" variables from the surrounding environment.

<?php
// Basic closure with use statement
$multiplier = 3;

$multiply = function($number) use ($multiplier) {
    return $number * $multiplier;
};

echo $multiply(4); // 12

// Multiple variables in use statement
$prefix = "Result: ";
$suffix = " (calculated)";

$format = function($value) use ($prefix, $suffix) {
    return $prefix . $value . $suffix;
};

echo $format(42); // Result: 42 (calculated)

// Demonstrating closure behavior
function createMultiplier($factor) {
    return function($number) use ($factor) {
        return $number * $factor;
    };
}

$double = createMultiplier(2);
$triple = createMultiplier(3);

echo $double(5); // 10
echo $triple(5); // 15
?>

Reference Binding with `use`

<?php
// Binding by value (default)
$counter = 0;

$incrementCopy = function() use ($counter) {
    $counter++; // This modifies the copy, not the original
    return $counter;
};

echo $incrementCopy(); // 1
echo $counter; // Still 0

// Binding by reference
$counter = 0;

$incrementRef = function() use (&$counter) {
    $counter++; // This modifies the original variable
    return $counter;
};

echo $incrementRef(); // 1
echo $counter; // Now 1

// Practical example: Event accumulator
$events = [];

$addEvent = function($event) use (&$events) {
    $events[] = [
        'event' => $event,
        'timestamp' => time()
    ];
};

$addEvent("User logged in");
$addEvent("Page viewed");

print_r($events);
?>

Advanced Closure Patterns

Closure Factories

<?php
// Factory function for creating specialized closures
function createValidator($type) {
    switch ($type) {
        case 'email':
            return function($value) {
                return filter_var($value, FILTER_VALIDATE_EMAIL) !== false;
            };
            
        case 'url':
            return function($value) {
                return filter_var($value, FILTER_VALIDATE_URL) !== false;
            };
            
        case 'range':
            return function($min, $max) {
                return function($value) use ($min, $max) {
                    return $value >= $min && $value <= $max;
                };
            };
            
        default:
            return function($value) {
                return true; // Default validator accepts everything
            };
    }
}

// Usage
$emailValidator = createValidator('email');
$rangeValidator = createValidator('range')(1, 100);

var_dump($emailValidator('[email protected]')); // true
var_dump($rangeValidator(50)); // true
var_dump($rangeValidator(150)); // false

// Configuration-based closure factory
function createApiClient($baseUrl, $apiKey) {
    return function($endpoint, $data = []) use ($baseUrl, $apiKey) {
        $url = $baseUrl . '/' . ltrim($endpoint, '/');
        
        $context = stream_context_create([
            'http' => [
                'method' => 'POST',
                'header' => [
                    'Authorization: Bearer ' . $apiKey,
                    'Content-Type: application/json'
                ],
                'content' => json_encode($data)
            ]
        ]);
        
        return file_get_contents($url, false, $context);
    };
}

$apiCall = createApiClient('https://api.example.com', 'your-api-key');
// $response = $apiCall('/users', ['name' => 'John']);
?>

Currying with Closures

<?php
// Simple currying example
function curry($func) {
    return function($a) use ($func) {
        return function($b) use ($func, $a) {
            return $func($a, $b);
        };
    };
}

// Original function
function add($a, $b) {
    return $a + $b;
}

// Curried version
$curriedAdd = curry('add');
$addFive = $curriedAdd(5);

echo $addFive(3); // 8
echo $addFive(7); // 12

// More advanced currying
function createCurriedFunction($func, $arity) {
    return function(...$args) use ($func, $arity) {
        if (count($args) >= $arity) {
            return call_user_func_array($func, array_slice($args, 0, $arity));
        }
        
        return function(...$nextArgs) use ($func, $arity, $args) {
            return createCurriedFunction($func, $arity)(...array_merge($args, $nextArgs));
        };
    };
}

// Three-parameter function
function calculateVolume($length, $width, $height) {
    return $length * $width * $height;
}

$curriedVolume = createCurriedFunction('calculateVolume', 3);

// Partial application
$volumeWithLength10 = $curriedVolume(10);
$volumeWithLength10Width5 = $volumeWithLength10(5);

echo $volumeWithLength10Width5(2); // 100
?>

Practical Applications

Event Listeners and Callbacks

<?php
class EventEmitter {
    private $listeners = [];
    
    public function on($event, callable $callback) {
        if (!isset($this->listeners[$event])) {
            $this->listeners[$event] = [];
        }
        $this->listeners[$event][] = $callback;
    }
    
    public function emit($event, ...$args) {
        if (isset($this->listeners[$event])) {
            foreach ($this->listeners[$event] as $callback) {
                call_user_func_array($callback, $args);
            }
        }
    }
}

// Usage with closures
$emitter = new EventEmitter();

// Simple event listener
$emitter->on('user.login', function($userId, $username) {
    echo "User $username (ID: $userId) logged in\n";
});

// Closure with captured variables
$logFile = 'app.log';
$emitter->on('user.login', function($userId, $username) use ($logFile) {
    file_put_contents($logFile, 
        date('Y-m-d H:i:s') . " - User $username logged in\n", 
        FILE_APPEND
    );
});

// Multiple listeners with different behaviors
$loginAttempts = [];
$emitter->on('user.login.failed', function($username, $ip) use (&$loginAttempts) {
    if (!isset($loginAttempts[$ip])) {
        $loginAttempts[$ip] = 0;
    }
    $loginAttempts[$ip]++;
    
    if ($loginAttempts[$ip] > 3) {
        echo "IP $ip blocked after multiple failed attempts\n";
    }
});

$emitter->emit('user.login', 123, 'john_doe');
$emitter->emit('user.login.failed', 'invalid_user', '192.168.1.100');
?>

Middleware Pattern

<?php
class MiddlewareStack {
    private $middlewares = [];
    
    public function add(callable $middleware) {
        $this->middlewares[] = $middleware;
    }
    
    public function execute($request, $response) {
        $index = 0;
        
        $next = function() use (&$index, $request, $response, &$next) {
            if ($index >= count($this->middlewares)) {
                return $response;
            }
            
            $middleware = $this->middlewares[$index++];
            return $middleware($request, $response, $next);
        };
        
        return $next();
    }
}

// Middleware functions using closures
$authMiddleware = function($request, $response, $next) {
    if (!isset($request['user'])) {
        $response['error'] = 'Unauthorized';
        $response['status'] = 401;
        return $response;
    }
    
    return $next();
};

$loggingMiddleware = function($request, $response, $next) {
    $start = microtime(true);
    
    $response = $next();
    
    $duration = microtime(true) - $start;
    error_log("Request processed in " . round($duration * 1000, 2) . "ms");
    
    return $response;
};

$rateLimitMiddleware = function($maxRequests) {
    static $requests = [];
    
    return function($request, $response, $next) use ($maxRequests, &$requests) {
        $ip = $request['ip'] ?? 'unknown';
        $requests[$ip] = ($requests[$ip] ?? 0) + 1;
        
        if ($requests[$ip] > $maxRequests) {
            $response['error'] = 'Rate limit exceeded';
            $response['status'] = 429;
            return $response;
        }
        
        return $next();
    };
};

// Usage
$stack = new MiddlewareStack();
$stack->add($loggingMiddleware);
$stack->add($authMiddleware);
$stack->add($rateLimitMiddleware(100));

$request = ['user' => 'john', 'ip' => '192.168.1.1'];
$response = ['status' => 200, 'data' => 'Success'];

$result = $stack->execute($request, $response);
print_r($result);
?>

Data Processing Pipelines

<?php
class Pipeline {
    private $stages = [];
    
    public function pipe(callable $stage) {
        $this->stages[] = $stage;
        return $this;
    }
    
    public function process($input) {
        return array_reduce($this->stages, function($carry, $stage) {
            return $stage($carry);
        }, $input);
    }
}

// Data transformation pipeline
$textProcessor = new Pipeline();

$textProcessor
    ->pipe(function($text) {
        return trim($text);
    })
    ->pipe(function($text) {
        return strtolower($text);
    })
    ->pipe(function($text) {
        return preg_replace('/[^a-z0-9\s]/', '', $text);
    })
    ->pipe(function($text) {
        return preg_replace('/\s+/', ' ', $text);
    })
    ->pipe(function($text) {
        return str_replace(' ', '-', $text);
    });

$result = $textProcessor->process("  Hello, World! This is a TEST.  ");
echo $result; // hello-world-this-is-a-test

// Number processing pipeline with closures
$mathPipeline = new Pipeline();

$multiplyBy = function($factor) {
    return function($number) use ($factor) {
        return $number * $factor;
    };
};

$addValue = function($value) {
    return function($number) use ($value) {
        return $number + $value;
    };
};

$mathPipeline
    ->pipe($multiplyBy(2))
    ->pipe($addValue(10))
    ->pipe(function($number) {
        return round($number, 2);
    });

echo $mathPipeline->process(5.7); // 21.4
?>

Memory Management and Performance

Closure Memory Considerations

<?php
// Memory-efficient closure creation
function createEfficientProcessor($config) {
    // Only capture what's needed
    $needed = [
        'multiplier' => $config['multiplier'],
        'format' => $config['format']
    ];
    
    return function($value) use ($needed) {
        $result = $value * $needed['multiplier'];
        return sprintf($needed['format'], $result);
    };
}

// Avoid capturing large objects unnecessarily
class LargeDataProcessor {
    private $largeData;
    
    public function __construct($data) {
        $this->largeData = $data; // Potentially large array/object
    }
    
    public function createProcessor() {
        // Bad: captures entire object
        // return function($input) {
        //     return $this->process($input);
        // };
        
        // Better: extract only what's needed
        $processingRules = $this->largeData['rules'];
        
        return function($input) use ($processingRules) {
            // Process using only the rules, not the entire large dataset
            return $this->processWithRules($input, $processingRules);
        };
    }
    
    private function processWithRules($input, $rules) {
        // Implementation here
        return $input;
    }
}

// Closure cleanup and circular references
function createTemporaryProcessor() {
    $tempData = range(1, 1000000); // Large temporary data
    
    $processor = function($input) use ($tempData) {
        return array_sum(array_slice($tempData, 0, $input));
    };
    
    // Process and clean up
    $result = $processor(10);
    
    // The closure and $tempData will be garbage collected
    // when $processor goes out of scope
    
    return $result;
}
?>

Performance Optimization

<?php
// Closure compilation and caching
class ClosureCache {
    private static $cache = [];
    
    public static function memoize(callable $func) {
        return function(...$args) use ($func) {
            $key = serialize($args);
            
            if (!isset(self::$cache[$key])) {
                self::$cache[$key] = $func(...$args);
            }
            
            return self::$cache[$key];
        };
    }
    
    public static function clearCache() {
        self::$cache = [];
    }
}

// Expensive function to memoize
$expensiveCalculation = function($n) {
    usleep(100000); // Simulate expensive operation
    return array_sum(range(1, $n));
};

$memoizedCalculation = ClosureCache::memoize($expensiveCalculation);

// First call - slow
$start = microtime(true);
echo $memoizedCalculation(1000);
echo " (Time: " . round((microtime(true) - $start) * 1000, 2) . "ms)\n";

// Second call - fast (cached)
$start = microtime(true);
echo $memoizedCalculation(1000);
echo " (Time: " . round((microtime(true) - $start) * 1000, 2) . "ms)\n";

// Lazy evaluation with closures
function lazyValue(callable $factory) {
    static $value = null;
    static $computed = false;
    
    if (!$computed) {
        $value = $factory();
        $computed = true;
    }
    
    return $value;
}

// Usage
$expensiveData = function() {
    echo "Computing expensive data...\n";
    return range(1, 100000);
};

// Value is not computed until first access
$lazy = function() use ($expensiveData) {
    return lazyValue($expensiveData);
};

echo "Lazy value created\n";
$data = $lazy(); // Now the expensive computation happens
echo "Data computed\n";
?>

Best Practices

Closure Design Guidelines

<?php
// 1. Keep closures small and focused
$validator = function($value, $rules) {
    foreach ($rules as $rule) {
        if (!$rule($value)) {
            return false;
        }
    }
    return true;
};

// 2. Use descriptive variable names in use statements
$createUserProcessor = function($database, $logger, $validator) {
    return function($userData) use ($database, $logger, $validator) {
        if (!$validator($userData)) {
            $logger->error('Invalid user data', $userData);
            return false;
        }
        
        return $database->createUser($userData);
    };
};

// 3. Avoid deep nesting
// Bad
$badNesting = function($a) {
    return function($b) use ($a) {
        return function($c) use ($a, $b) {
            return function($d) use ($a, $b, $c) {
                return $a + $b + $c + $d;
            };
        };
    };
};

// Better
class Calculator {
    private $values = [];
    
    public function add($value) {
        $this->values[] = $value;
        return $this;
    }
    
    public function sum() {
        return array_sum($this->values);
    }
}

// 4. Document closure parameters and return types
/**
 * Creates a formatter closure
 * 
 * @param string $template The template string with placeholders
 * @return callable(array): string A closure that accepts data and returns formatted string
 */
function createFormatter($template) {
    return function(array $data) use ($template) {
        return preg_replace_callback('/\{(\w+)\}/', function($matches) use ($data) {
            return $data[$matches[1]] ?? '';
        }, $template);
    };
}

// 5. Handle errors gracefully in closures
$safeProcessor = function($data) {
    return function($processor) use ($data) {
        try {
            return ['success' => true, 'result' => $processor($data)];
        } catch (Exception $e) {
            return ['success' => false, 'error' => $e->getMessage()];
        }
    };
};

// Usage
$process = $safeProcessor(['name' => 'John']);

$result = $process(function($data) {
    if (empty($data['name'])) {
        throw new InvalidArgumentException('Name is required');
    }
    return strtoupper($data['name']);
});

print_r($result); // ['success' => true, 'result' => 'JOHN']
?>

Closures and anonymous functions are powerful features in PHP that enable functional programming patterns, flexible callback systems, and elegant solutions to complex problems. They're essential for modern PHP development and form the foundation for many advanced programming techniques.

Introduction to Closures and Anonymous Functions

Anonymous Functions

Basic Anonymous Functions

Function Parameters and Return Types

Closures and Variable Binding

The use Statement

Reference Binding with use

Advanced Closure Patterns

Closure Factories

Currying with Closures

Practical Applications

Event Listeners and Callbacks

Middleware Pattern

Data Processing Pipelines

Memory Management and Performance

Closure Memory Considerations

Performance Optimization

Best Practices

Closure Design Guidelines

On this page

Introduction to Closures and Anonymous Functions

Anonymous Functions

Closures and Variable Binding

Advanced Closure Patterns

Practical Applications

Memory Management and Performance

Best Practices

The `use` Statement

Reference Binding with `use`