PHP Functions: Anonymous Functions and Closures

Duration: 45 minutes

Module 2: Functions in PHP

Learning Objectives

Create and use PHP functions
Understand function parameters and returns
Master variable scope in functions
Build reusable code components

Unlocking Flexible Function Power

Welcome to our exploration of anonymous functions and closures in PHP! These powerful features allow you to create functions on the fly, pass them as arguments, and encapsulate specific behaviors in elegant ways that can dramatically improve your WordPress development.

Think of anonymous functions like temporary workers you can hire for specific tasks without going through the formal process of creating a permanent employee. They show up, do exactly what you need, and integrate seamlessly with your existing team.

What Are Anonymous Functions and Closures?

Anonymous Functions are functions without a name that can be created and used inline. They're also called lambda functions in some programming languages.

Closures are anonymous functions that can access variables from their parent scope. They "close over" variables from the surrounding context.

Understanding Anonymous Functions: A Visual Model

Think of a named function like a dedicated tool in your workshop - it has a specific name, place, and purpose. An anonymous function is more like a temporary tool you create for a specific job and then store in a variable or pass along to be used elsewhere.

Creating and Using Anonymous Functions

Anonymous functions in PHP are created with the function keyword, but without a name. They're typically assigned to variables or passed directly as arguments.

Basic Anonymous Function Syntax

$functionName = function($param1, $param2) {
    // Function body
    return $result;
};

Note the semicolon at the end of the function definition - it's required because this is an expression assignment, not a function declaration.

Simple Anonymous Function Example

// Create an anonymous function and assign it to a variable
$greeting = function($name) {
    return "Hello, $name!";
};

// Use the function
echo $greeting("WordPress Developer"); // Outputs: Hello, WordPress Developer!

Once assigned to a variable, you can use an anonymous function just like any other function - call it with arguments, capture its return value, and so on.

Using Anonymous Functions as Arguments

// A function that takes another function as an argument
function processList($items, $formatter) {
    $result = "";
    foreach ($items as $item) {
        $result .= $formatter($item) . "
";
    }
    return $result;
}

// Pass an anonymous function as an argument
$output = processList(
    ['Home', 'About', 'Contact'], 
    function($text) {
        return "• " . strtoupper($text);
    }
);

echo $output;
// Outputs:
// • HOME
// • ABOUT
// • CONTACT

This ability to pass functions as arguments opens up powerful programming patterns that we'll explore throughout this lecture.

Understanding Closures: Functions with Memory

A closure is a special type of anonymous function that "remembers" the environment in which it was created. This means it can access variables from the outer scope where it was defined.

Diagram

Basic Closure Example

// Outer scope variable
$prefix = "WordPress_";

// Create a closure that uses the outer scope variable
$addPrefix = function($string) use ($prefix) {
    return $prefix . $string;
};

// Use the closure
echo $addPrefix("Plugin"); // Outputs: WordPress_Plugin

The use keyword is essential here - it tells PHP which variables from the outer scope should be available inside the closure.

Multiple Variables in Closures

$firstName = "John";
$lastName = "Doe";

$formatName = function($format) use ($firstName, $lastName) {
    switch ($format) {
        case 'full':
            return "$firstName $lastName";
        case 'last_first':
            return "$lastName, $firstName";
        case 'initials':
            return strtoupper(substr($firstName, 0, 1) . substr($lastName, 0, 1));
        default:
            return $firstName;
    }
};

echo $formatName('full');       // Outputs: John Doe
echo $formatName('last_first'); // Outputs: Doe, John
echo $formatName('initials');   // Outputs: JD

You can capture multiple variables from the outer scope by listing them in the use statement.

Capturing Variables by Value vs. Reference

By default, when a closure captures variables with use, it captures them by value (makes a copy). Sometimes, you want to capture by reference to see or make changes to the original variable.

Capture By Value (Default)

$counter = 0;

$incrementByValue = function() use ($counter) {
    $counter++;
    return $counter;
};

echo $incrementByValue(); // Outputs: 1
echo $incrementByValue(); // Outputs: 1 (still 1, not 2)
echo $counter;           // Outputs: 0 (original unchanged)

Capture By Reference

$counter = 0;

$incrementByReference = function() use (&$counter) {
    $counter++;
    return $counter;
};

echo $incrementByReference(); // Outputs: 1
echo $incrementByReference(); // Outputs: 2
echo $counter;               // Outputs: 2 (original was modified)

The ampersand (&) before the variable name in the use statement is the key difference. It tells PHP to capture a reference to the original variable rather than making a copy.

Common Use Cases for Anonymous Functions

Diagram

Array Operations with Anonymous Functions

$posts = [
    ['title' => 'Getting Started with WordPress', 'comments' => 5, 'status' => 'publish'],
    ['title' => 'Advanced Theme Development', 'comments' => 12, 'status' => 'draft'],
    ['title' => 'Optimizing WordPress Performance', 'comments' => 8, 'status' => 'publish'],
    ['title' => 'WordPress Security Best Practices', 'comments' => 20, 'status' => 'publish']
];

// Filter published posts using array_filter
$publishedPosts = array_filter($posts, function($post) {
    return $post['status'] === 'publish';
});

// Sort posts by comment count using usort
usort($publishedPosts, function($a, $b) {
    return $b['comments'] - $a['comments']; // Sort in descending order
});

// Extract just the titles using array_map
$titles = array_map(function($post) {
    return $post['title'];
}, $publishedPosts);

// Display results
foreach ($titles as $title) {
    echo $title . "
";
}

// Outputs:
// WordPress Security Best Practices
// Optimizing WordPress Performance
// Getting Started with WordPress

Custom Sorting with Anonymous Functions

$users = [
    ['name' => 'John', 'role' => 'editor', 'last_active' => '2025-01-15'],
    ['name' => 'Sarah', 'role' => 'administrator', 'last_active' => '2025-04-20'],
    ['name' => 'Mike', 'role' => 'subscriber', 'last_active' => '2025-03-10'],
    ['name' => 'Lisa', 'role' => 'editor', 'last_active' => '2025-02-28']
];

// Custom sort function that prioritizes role and then last_active date
usort($users, function($a, $b) {
    // Define role priority (higher number = higher priority)
    $rolePriority = [
        'administrator' => 3,
        'editor' => 2,
        'author' => 1,
        'subscriber' => 0
    ];
    
    // Compare roles first
    $roleComparison = $rolePriority[$b['role']] - $rolePriority[$a['role']];
    
    // If roles are the same, compare by last active date
    if ($roleComparison === 0) {
        return strtotime($b['last_active']) - strtotime($a['last_active']);
    }
    
    return $roleComparison;
});

// Display sorted users
foreach ($users as $user) {
    echo "{$user['name']} ({$user['role']}) - Last active: {$user['last_active']}
";
}

// Outputs:
// Sarah (administrator) - Last active: 2025-04-20
// Lisa (editor) - Last active: 2025-02-28
// John (editor) - Last active: 2025-01-15
// Mike (subscriber) - Last active: 2025-03-10

Anonymous Functions with WordPress Hooks

WordPress's hook system (actions and filters) is one of the most powerful places to use anonymous functions. They allow you to hook into WordPress without creating named functions that might conflict with other code.

WordPress Action Hooks with Anonymous Functions

// Add custom admin footer text using an anonymous function
add_action('admin_footer_text', function() {
    echo 'Thank you for creating with WordPress | ';
    echo 'Theme by: Your Name';
});

// Add custom CSS to the head section of your site
add_action('wp_head', function() {
    ?>
    <style>
        .site-header {
            background-color: #2c3e50;
            color: white;
        }
        .entry-title {
            color: #3498db;
        }
    </style>
    
        <script>
            document.addEventListener('DOMContentLoaded', function() {
                console.log('Front page loaded!');
            });
        </script>



            
                WordPress Filter Hooks with Anonymous Functions
                // Modify post content with an anonymous function
add_filter('the_content', function($content) {
    // Only modify single post content
    if (is_single() && !is_admin()) {
        // Add a "Thanks for reading" message at the end
        $content .= '<div class="thank-you-message">';
        $content .= '<p>Thanks for reading! If you enjoyed this post, please share it.</p>';
        $content .= '</div>';
    }
    return $content;
});

// Add custom body classes with an anonymous function
add_filter('body_class', function($classes) {
    // Add a class based on user role
    if (is_user_logged_in()) {
        $user = wp_get_current_user();
        $role = $user->roles[0];
        $classes[] = 'user-role-' . $role;
    }
    
    // Add a class for posts with no thumbnail
    if (is_single() && !has_post_thumbnail()) {
        $classes[] = 'no-featured-image';
    }
    
    return $classes;
});
            

            
                Using Closures with WordPress Hooks
                // Capture site configuration in a closure
$site_config = [
    'show_breadcrumbs' => true,
    'enable_animations' => true,
    'primary_color' => '#3498db'
];

// Use the configuration in a filter hook
add_filter('the_title', function($title) use ($site_config) {
    // Only modify archive page titles
    if (is_archive() && $site_config['show_breadcrumbs']) {
        $title = '<span style="color:' . $site_config['primary_color'] . '">' . $title . '</span>';
    }
    return $title;
});

// Counter for tracking post views with a closure
add_action('wp_footer', function() {
    static $posts_shown = 0;
    
    // Only increment on single post views
    if (is_single()) {
        $posts_shown++;
        echo '<script>console.log("Post view count: ' . $posts_shown . '");</script>';
    }
});
            
            
            Notice how static variables can be used inside anonymous functions attached to hooks to maintain state across multiple calls.



        
            Function Factories: Creating Functions with Functions
            
            One powerful pattern with closures is creating "function factories" - functions that generate and return other functions with specific behaviors.


Diagram

    

                Basic Function Factory Example
                // A function that creates custom formatter functions
function createFormatter($format) {
    return function($content) use ($format) {
        switch ($format) {
            case 'uppercase':
                return strtoupper($content);
            case 'lowercase':
                return strtolower($content);
            case 'title':
                return ucwords(strtolower($content));
            case 'slug':
                return strtolower(str_replace(' ', '-', $content));
            default:
                return $content;
        }
    };
}

// Create specific formatter functions
$uppercaseFormatter = createFormatter('uppercase');
$titleFormatter = createFormatter('title');
$slugFormatter = createFormatter('slug');

// Use the formatters
$text = "welcome to wordpress development";
echo $uppercaseFormatter($text) . "
"; // WELCOME TO WORDPRESS DEVELOPMENT
echo $titleFormatter($text) . "
";     // Welcome To Wordpress Development
echo $slugFormatter($text) . "
";      // welcome-to-wordpress-development
            

            
                WordPress Function Factory for Shortcodes
                // Factory that creates custom button shortcode handlers
function create_button_shortcode($style) {
    // Each closure captures its own style
    $shortcode_handler = function($atts, $content = null) use ($style) {
        $attributes = shortcode_atts([
            'url' => '#',
            'target' => '_self',
            'size' => 'medium',
            'align' => 'center'
        ], $atts);
        
        $class = "btn btn-{$style} btn-{$attributes['size']}";
        $alignment = $attributes['align'] !== 'none' ? "text-{$attributes['align']}" : '';
        
        return "<div class=\"{$alignment}\">".
               "<a href=\"{$attributes['url']}\" target=\"{$attributes['target']}\" class=\"{$class}\">".
               $content .
               "</a></div>";
    };
    
    return $shortcode_handler;
}

// Register multiple button shortcodes with different styles
add_shortcode('primary_button', create_button_shortcode('primary'));
add_shortcode('success_button', create_button_shortcode('success'));
add_shortcode('warning_button', create_button_shortcode('warning'));
add_shortcode('danger_button', create_button_shortcode('danger'));

// Usage in WordPress content:
// [primary_button url="https://example.com" size="large"]Click Me[/primary_button]
// [success_button url="https://example.com/signup"]Sign Up[/success_button]
            

            Function factories reduce code duplication and create highly customized functions for specific purposes, all while maintaining a clean API.
        

        
            Arrow Functions (PHP 7.4+)
            
            In PHP 7.4 and above, there's a shorter syntax for simple anonymous functions called "arrow functions" or "short closures." They're perfect for brief, single-expression functions.
            
            
                Arrow Function Syntax
                // Traditional anonymous function
$double = function($x) {
    return $x * 2;
};

// Equivalent arrow function
$double = fn($x) => $x * 2;

// Both work the same way
echo $double(5); // Outputs: 10
            

            Arrow functions are especially useful for array operations with callback functions, making your code more concise and readable.
            
            
                Arrow Functions with Array Operations
                $posts = [
    ['id' => 1, 'title' => 'First Post', 'comments' => 5],
    ['id' => 2, 'title' => 'Second Post', 'comments' => 3],
    ['id' => 3, 'title' => 'Third Post', 'comments' => 8]
];

// Traditional anonymous functions
$titles = array_map(function($post) {
    return $post['title'];
}, $posts);

// With arrow functions
$titles = array_map(fn($post) => $post['title'], $posts);

// Filter posts with more than 5 comments
$popularPosts = array_filter($posts, fn($post) => $post['comments'] > 5);

// Calculate total comments with array_reduce
$totalComments = array_reduce($posts, fn($carry, $post) => $carry + $post['comments'], 0);

echo "Total comments: $totalComments"; // Outputs: Total comments: 16
            

            
                Important Notes About Arrow Functions
                
                    Arrow functions automatically capture variables from the parent scope without needing use
                    They can only contain a single expression (no multi-line function bodies)
                    They implicitly return the value of the expression
                    All captures are by-value unless you explicitly use references in the parent scope
                    They're only available in PHP 7.4 and above
                
            
        

        
            Practical WordPress Development Examples
            
            
                Custom Walker with Anonymous Function
                // Display a custom menu with specific styling using anonymous functions
function display_custom_menu($menu_location) {
    // Check if menu exists
    if (!has_nav_menu($menu_location)) {
        return;
    }
    
    // Custom walker using anonymous classes and functions
    $custom_walker = new class extends Walker_Nav_Menu {
        public function start_el(&$output, $item, $depth = 0, $args = null, $id = 0) {
            // Create a processor based on depth
            $processor = function($item, $depth) {
                $classes = empty($item->classes) ? [] : (array) $item->classes;
                
                // Add depth-specific classes
                $classes[] = 'menu-item-depth-' . $depth;
                
                // Add active class if needed
                if (in_array('current-menu-item', $classes)) {
                    $classes[] = 'active';
                }
                
                // Filter the classes
                $class_names = implode(' ', apply_filters('nav_menu_css_class', array_filter($classes), $item, $args, $depth));
                $class_names = $class_names ? ' class="' . esc-attr($class_names) . '"' : '';
                
                // Generate ID
                $id = apply_filters('nav_menu_item_id', 'menu-item-' . $item->ID, $item, $args, $depth);
                $id = $id ? ' id="' . esc_attr($id) . '"' : '';
                
                // Return the formatted list item start
                return "<li{$id}{$class_names}>";
            };
            
            // Add the item to output
            $output .= $processor($item, $depth);
            
            // Add the link
            $attributes = '';
            foreach (['title', 'target', 'rel', 'href', 'class'] as $attr) {
                if (!empty($item->$attr)) {
                    $attributes .= ' ' . $attr . '="' . esc_attr($item->$attr) . '"';
                }
            }
            
            $title = apply_filters('the_title', $item->title, $item->ID);
            $item_output = $args->before;
            $item_output .= "<a{$attributes}>";
            $item_output .= $args->link_before . $title . $args->link_after;
            $item_output .= '</a>';
            $item_output .= $args->after;
            
            $output .= apply_filters('walker_nav_menu_start_el', $item_output, $item, $depth, $args);
        }
    };
    
    // Display the menu
    wp_nav_menu([
        'theme_location' => $menu_location,
        'container' => 'nav',
        'container_class' => 'custom-menu-container',
        'menu_class' => 'custom-menu',
        'walker' => $custom_walker
    ]);
}
            

            
                WordPress Plugin with Callback Registry
                /**
 * Simple Callback Registry for a Hypothetical Plugin
 */
class MyPlugin_Callback_Registry {
    private $callbacks = [];
    
    /**
     * Register a callback for a specific event
     */
    public function register($event, $callback) {
        if (!isset($this->callbacks[$event])) {
            $this->callbacks[$event] = [];
        }
        
        $this->callbacks[$event][] = $callback;
        return $this;
    }
    
    /**
     * Execute all callbacks for an event
     */
    public function execute($event, $data = null) {
        if (!isset($this->callbacks[$event])) {
            return $data;
        }
        
        $result = $data;
        
        foreach ($this->callbacks[$event] as $callback) {
            $result = $callback($result);
        }
        
        return $result;
    }
}

// Usage example
$registry = new MyPlugin_Callback_Registry();

// Register formatters for different content types
$registry->register('format_title', function($title) {
    return strtoupper($title);
});

$registry->register('format_content', function($content) {
    return '<div class="formatted-content">' . $content . '</div>';
});

// Register multiple transformations for a single event type
$registry->register('transform_data', function($data) {
    // Add timestamp
    $data['timestamp'] = time();
    return $data;
});

$registry->register('transform_data', function($data) {
    // Add process ID
    $data['process_id'] = uniqid();
    return $data;
});

// Execute the callbacks
$title = $registry->execute('format_title', 'Welcome to WordPress');
$content = $registry->execute('format_content', 'This is some sample content.');
$data = $registry->execute('transform_data', ['source' => 'user_input']);

echo $title . '
';  // Outputs: WELCOME TO WORDPRESS
echo $content . '
'; // Outputs: This is some sample content.
print_r($data);         // Outputs: Array with source, timestamp, and process_id keys
            
        

        
            When to Use Anonymous vs. Named Functions
            
            
                Anonymous Functions vs. Named Functions
                
                    
                        Use Anonymous Functions When
                        Use Named Functions When
                    
                    
                        The function is only used once
                        The function needs to be used in multiple places
                    
                    
                        The function is simple and short
                        The function is complex or long
                    
                    
                        You need to capture variables from the parent scope
                        The function should be completely independent
                    
                    
                        You're passing a callback to another function
                        You need to call the function recursively
                    
                    
                        You want to avoid polluting the global namespace
                        You want to make the function available globally
                    
                    
                        You're adding a hook or filter that's only used once
                        You're creating a callback that will be used by multiple hooks
                    
                
            
            
            
                Best Practices for Anonymous Functions
                
                    Keep them short and focused: If your anonymous function exceeds 10-15 lines, consider making it a named function instead
                    Use meaningful variable names: Since anonymous functions lack descriptive names, use clear variable names when assigning them
                    Comment complex logic: Add comments to explain what your anonymous function does, especially if it contains complex logic
                    Be mindful of memory: Closures that capture many variables can increase memory usage
                    Use arrow functions (PHP 7.4+): For simple operations, prefer the shorter arrow function syntax
                    Consider readability: Sometimes a named function is more readable than an anonymous one, even if used only once
                
            
        

        
            Advanced Closure Techniques
            
            
                Self-Executing Anonymous Functions
                // Basic self-executing anonymous function
(function() {
    echo "This runs immediately!";
})();

// Useful for creating isolated scopes
(function() {
    // Variables defined here won't affect the global scope
    $localVar = "I'm local to this function";
    echo $localVar;
})();

// Passing parameters to self-executing functions
(function($name) {
    echo "Hello, $name!";
})("WordPress Developer");

// Practical WordPress example: One-time setup code
add_action('init', function() {
    // This runs once during WordPress initialization
    (function() {
        // Register a custom post type
        register_post_type('portfolio', [
            'labels' => [
                'name' => 'Portfolio Items',
                'singular_name' => 'Portfolio Item'
            ],
            'public' => true,
            'has_archive' => true,
            'supports' => ['title', 'editor', 'thumbnail']
        ]);
        
        // Register a taxonomy
        register_taxonomy('portfolio_category', 'portfolio', [
            'labels' => [
                'name' => 'Categories',
                'singular_name' => 'Category'
            ],
            'hierarchical' => true,
            'show_admin_column' => true
        ]);
    })();
});
            

            
                Recursive Anonymous Functions with Static Variables
                // Create a recursive function to process nested menu items
$process_menu = function($items, $parent_id = 0) use (&$process_menu) {
    $output = '';
    
    foreach ($items as $item) {
        if ($item['parent_id'] == $parent_id) {
            $output .= '<li>';
            $output .= $item['title'];
            
            // Look for children
            $children = '';
            $children = $process_menu($items, $item['id']);
            
            if ($children) {
                $output .= '<ul>' . $children . '</ul>';
            }
            
            $output .= '</li>';
        }
    }
    
    return $output;
};

// Sample menu items
$menu_items = [
    ['id' => 1, 'title' => 'Home', 'parent_id' => 0],
    ['id' => 2, 'title' => 'About', 'parent_id' => 0],
    ['id' => 3, 'title' => 'Services', 'parent_id' => 0],
    ['id' => 4, 'title' => 'Web Design', 'parent_id' => 3],
    ['id' => 5, 'title' => 'WordPress Development', 'parent_id' => 3],
    ['id' => 6, 'title' => 'Team', 'parent_id' => 2],
    ['id' => 7, 'title' => 'History', 'parent_id' => 2]
];

// Generate menu HTML
$menu_html = '<ul>' . $process_menu($menu_items) . '</ul>';
echo $menu_html;
            
            
            Note the use (&$process_menu) statement which allows the function to reference itself for recursion.
        

        
            Debugging Anonymous Functions and Closures
            
            Anonymous functions can sometimes be tricky to debug because they don't have names that appear in stack traces. Here are some strategies for effective debugging.
            
            
                Debugging Tips
                
                    Use descriptive variable names: Name the variables holding your anonymous functions descriptively
                    Add internal logging: Include error logging or debug output inside your functions
                    Test closures in isolation: Before using a closure in a complex context, test it separately
                    Check captured variables: Verify that closures are capturing the variables you expect
                    Wrap in try/catch blocks: Catch and log errors that occur inside anonymous functions
                
            
            
            
                Debugging Closure Example
                // A problematic closure
$process_data = function($data) use ($config) {
    try {
        // Add debug logging
        error_log('Processing data with config: ' . print_r($config, true));
        
        // Check if required variables are set
        if (!isset($config['processor']) || !isset($data['input'])) {
            error_log('Missing required variables in closure');
            return false;
        }
        
        // Process the data
        $result = $config['processor']($data['input']);
        
        // Verify result
        error_log('Result: ' . print_r($result, true));
        
        return $result;
    } catch (Exception $e) {
        // Catch and log errors
        error_log('Error in process_data closure: ' . $e->getMessage());
        return false;
    }
};

// When adding to WordPress hooks, wrap with identifiable try/catch
add_filter('the_content', function($content) use ($my_plugin_settings) {
    try {
        // Your processing code here
        return $processed_content;
    } catch (Exception $e) {
        error_log('Error in my_plugin content filter: ' . $e->getMessage());
        return $content; // Return original content on error
    }
});
            
        

        
            Practice Exercises
            
            
                Exercise 1: Array Transformation
                Create a function that takes an array of post objects and a formatter function as parameters. The function should apply the formatter to each post's title and return a new array with the formatted titles.
                Then create several different formatter anonymous functions (uppercase, lowercase, with prefix, etc.) and test them with your function.
            
            
            
                Exercise 2: WordPress Hook Callbacks
                Write at least three different anonymous functions for WordPress hooks:
                
                    A filter for the_title that adds the post ID in parentheses but only on archive pages
                    An action for wp_footer that adds a "Back to Top" button only on long pages
                    A filter for body_class that adds classes based on the time of day (morning, afternoon, evening)
                
            
            
            
                Exercise 3: Function Factory
                Create a function factory that generates different text formatter functions based on a configuration array. The factory should support at least:
                
                    Text case transformations (upper, lower, title case)
                    Text wrapping (with HTML tags or other delimiters)
                    Text truncation (limiting to a specified number of words)
                
                Then use your factory to create specialized formatters for different parts of a WordPress site (headings, excerpts, footers, etc.).
            
        

        
            Further Reading
            
            
                PHP Manual: Anonymous Functions
                PHP Manual: Arrow Functions
                WordPress Function Reference: add_filter()
                WordPress Developer Handbook: Callback Functions
            
        

        
            Coming Up Next
            
            In our next lecture, we'll explore built-in PHP functions - the extensive collection of pre-defined functions that PHP provides to help you with common tasks.
            
            
                
                    Overview of PHP's function libraries
                    String manipulation functions
                    Array and data handling functions
                    File system functions
                    Date and time functions
                    How to use the PHP documentation
                
            
        
            




Back to

                                    Module 2 Overview
                                




Next Module

                                    Module 3: MySQL Database

Course Progress

Learning Objectives

Unlocking Flexible Function Power

What Are Anonymous Functions and Closures?

Understanding Anonymous Functions: A Visual Model

Creating and Using Anonymous Functions

Basic Anonymous Function Syntax

Simple Anonymous Function Example

Using Anonymous Functions as Arguments

Understanding Closures: Functions with Memory

Basic Closure Example

Multiple Variables in Closures

Capturing Variables by Value vs. Reference

Capture By Value (Default)

Capture By Reference

Common Use Cases for Anonymous Functions

Array Operations with Anonymous Functions

Custom Sorting with Anonymous Functions

Anonymous Functions with WordPress Hooks

WordPress Action Hooks with Anonymous Functions

WordPress Filter Hooks with Anonymous Functions

Using Closures with WordPress Hooks

Function Factories: Creating Functions with Functions

Basic Function Factory Example

WordPress Function Factory for Shortcodes

Arrow Functions (PHP 7.4+)

Arrow Function Syntax

Arrow Functions with Array Operations

Important Notes About Arrow Functions

Practical WordPress Development Examples

Custom Walker with Anonymous Function

WordPress Plugin with Callback Registry

When to Use Anonymous vs. Named Functions

Anonymous Functions vs. Named Functions

Best Practices for Anonymous Functions

Advanced Closure Techniques

Self-Executing Anonymous Functions

Recursive Anonymous Functions with Static Variables

Debugging Anonymous Functions and Closures

Debugging Tips

Debugging Closure Example

Practice Exercises

Exercise 1: Array Transformation

Exercise 2: WordPress Hook Callbacks

Exercise 3: Function Factory

Further Reading

Coming Up Next