PHP Array Functions: Powerful Tools for Data Manipulation

Duration: 45 minutes

Module 2: Arrays and Data Manipulation

Learning Objectives

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

Understanding the Power of PHP Arrays

Welcome to our deep dive into PHP array functions! Arrays are the workhorses of PHP programming - they're like the Swiss Army knives in your development toolkit. Think of PHP arrays as organized containers that can hold multiple values under a single variable name, similar to how a filing cabinet organizes folders or how a toolbox stores different tools.

In today's digital landscape, data is everywhere. As web developers, our job is to collect, organize, manipulate, and present this data effectively. PHP arrays and their associated functions give us the power to do exactly that - whether we're building e-commerce platforms, content management systems like WordPress, or data-driven applications.

Types of PHP Arrays: A Quick Review

Before we dive into the powerful array functions PHP offers, let's quickly refresh our understanding of the three main types of arrays you'll be working with:

Indexed Arrays

These arrays use numeric indexes to access values. Think of them as numbered shelves in a bookcase - each position has a specific number to identify it.

// Indexed array example
$fruits = ["Apple", "Banana", "Cherry", "Dragon fruit"];
echo $fruits[0];  // Outputs: Apple
echo $fruits[2];  // Outputs: Cherry

Diagram

Associative Arrays

These arrays use named keys to access values. Think of them as a labeled storage cabinet, where each drawer has a descriptive name rather than just a number.

// Associative array example
$user = [
    "name" => "John Doe",
    "email" => "john@example.com",
    "age" => 28,
    "is_admin" => false
];
echo $user["name"];  // Outputs: John Doe
echo $user["age"];   // Outputs: 28

Diagram

Multidimensional Arrays

These are arrays containing other arrays. Think of them as filing cabinets with drawers that contain folders, which in turn contain documents - they organize data in multiple layers.

// Multidimensional array example
$employees = [
    [
        "name" => "Sarah Johnson",
        "position" => "Web Developer",
        "skills" => ["PHP", "JavaScript", "MySQL"]
    ],
    [
        "name" => "Mark Williams",
        "position" => "Designer",
        "skills" => ["Photoshop", "Illustrator", "UX Design"]
    ]
];
echo $employees[0]["name"];        // Outputs: Sarah Johnson
echo $employees[1]["skills"][0];   // Outputs: Photoshop

Essential Array Functions: Your Developer Toolkit

Now that we've refreshed our understanding of array types, let's explore the powerful functions PHP provides to manipulate them. Think of these functions as specialized tools designed for specific jobs - just as a carpenter has specific tools for cutting, measuring, and joining wood.

Array Information Functions

These functions help you understand and inspect your arrays - like gauges and measuring tools that tell you about your data.

count() - Counting Array Elements

The count() function returns the number of elements in an array. It's like quickly counting how many items are in a container.

$fruits = ["Apple", "Banana", "Cherry", "Dragon fruit"];
echo count($fruits);  // Outputs: 4

$nested_array = [1, 2, [3, 4, 5]];
echo count($nested_array);  // Outputs: 3
echo count($nested_array, COUNT_RECURSIVE);  // Outputs: 5 (counts nested elements too)

Real-world application: When displaying pagination for a product catalog, you might use count() to determine how many pages are needed based on the total number of products.

sizeof() - An Alias of count()

sizeof() is identical to count() - it's simply an alternative name for the same function. Some developers prefer it when working with arrays because it mimics naming conventions from other programming languages.

$cart_items = ["Laptop", "Mouse", "Keyboard"];
echo sizeof($cart_items);  // Outputs: 3

empty() - Checking if an Array is Empty

The empty() function checks if an array (or variable) is empty. It's like checking if a container has anything in it before you try to use its contents.

$empty_array = [];
if (empty($empty_array)) {
    echo "The array is empty";
}

// A practical example with a shopping cart
$cart = [];
if (empty($cart)) {
    echo "Your shopping cart is empty. Continue shopping!";
} else {
    echo "You have " . count($cart) . " items in your cart.";
}

Real-world application: In WordPress plugin development, you might check if an array of plugin settings is empty before applying default values.

isset() - Checking if an Array Key Exists

The isset() function checks if a specific key exists in an array and is not NULL. It's like checking if a specific labeled drawer exists in a filing cabinet.

$user = [
    "name" => "John Doe",
    "email" => "john@example.com"
];

if (isset($user["name"])) {
    echo "User name is set: " . $user["name"];
}

if (!isset($user["phone"])) {
    echo "Phone number is not set!";
}

Real-world application: When processing form submissions, use isset() to check if optional fields were filled out before processing them.

array_key_exists() - Checking if a Key Exists

Similar to isset(), but array_key_exists() only checks if the key exists, regardless of whether its value is NULL. It's like checking if a label exists on a container, even if the container is empty.

$settings = [
    "debug_mode" => true,
    "cache_enabled" => false,
    "temp_directory" => null
];

// This returns true
if (array_key_exists("temp_directory", $settings)) {
    echo "Temp directory setting exists";
}

// This returns false because isset() considers null values as "not set"
if (isset($settings["temp_directory"])) {
    echo "This won't be displayed";
}

When to use array_key_exists() vs isset():

Use isset() when you want to check if a key exists AND has a non-null value
Use array_key_exists() when you only need to check if the key exists in the array, regardless of its value
isset() is generally faster but less precise

in_array() - Checking if a Value Exists

The in_array() function checks if a specific value exists in an array. It's like searching through a stack of papers to find a document with specific content.

$allowed_roles = ["admin", "editor", "author"];

$user_role = "editor";
if (in_array($user_role, $allowed_roles)) {
    echo "Access granted!";
} else {
    echo "Access denied!";
}

// Strict comparison (type checking)
$numbers = [1, 2, "3", 4];
var_dump(in_array(3, $numbers));       // Returns true (loose comparison)
var_dump(in_array(3, $numbers, true)); // Returns false (strict comparison)

Real-world application: When building an access control system, use in_array() to check if a user's role is in a list of roles authorized to access a specific feature.

array_search() - Finding a Value's Position

The array_search() function searches for a value in an array and returns its key if found. It's like not only finding a document but noting which folder it was stored in.

$fruits = ["Apple", "Banana", "Cherry", "Dragon fruit"];
$position = array_search("Cherry", $fruits);
echo $position;  // Outputs: 2

// In an associative array
$employees = [
    "E001" => "John Doe",
    "E002" => "Jane Smith",
    "E003" => "Robert Johnson"
];

$employee_id = array_search("Jane Smith", $employees);
echo $employee_id;  // Outputs: E002

Real-world application: In an e-commerce application, use array_search() to find the position of a product in a list of featured products to determine its display order.

Array Manipulation Functions

These functions allow you to modify and transform arrays - like tools that reshape and reorganize your data containers.

array_push() - Adding Elements to the End

The array_push() function adds one or more elements to the end of an array. It's like adding new items to the back of a queue or the top of a stack.

$technologies = ["PHP", "HTML", "CSS"];
array_push($technologies, "JavaScript", "MySQL");
print_r($technologies);
// Outputs: Array ( [0] => PHP [1] => HTML [2] => CSS [3] => JavaScript [4] => MySQL )

// Alternative syntax using the array operator
$technologies[] = "Docker";
print_r($technologies);
// Outputs: Array ( [0] => PHP [1] => HTML [2] => CSS [3] => JavaScript [4] => MySQL [5] => Docker )

Real-world application: When users browse products on an e-commerce site, use array_push() to add products to their recently viewed items list.

array_pop() - Removing the Last Element

The array_pop() function removes the last element from an array and returns it. It's like taking the top item off a stack.

$task_queue = ["Research", "Design", "Development", "Testing", "Deployment"];
$current_task = array_pop($task_queue);
echo "Current task: " . $current_task; // Outputs: Current task: Deployment
print_r($task_queue);
// Outputs: Array ( [0] => Research [1] => Design [2] => Development [3] => Testing )

Real-world application: In a task management application, use array_pop() to remove and retrieve the most recently added task from a stack of pending tasks.

array_unshift() - Adding Elements to the Beginning

The array_unshift() function adds one or more elements to the beginning of an array. It's like adding new items to the front of a queue.

$notifications = ["New message from Jane", "Meeting reminder"];
array_unshift($notifications, "System update required", "New login detected");
print_r($notifications);
// Outputs: Array ( [0] => System update required [1] => New login detected
//                  [2] => New message from Jane [3] => Meeting reminder )

Real-world application: In a news feed or notification system, use array_unshift() to add new notifications to the top of the list so they appear first.

array_shift() - Removing the First Element

The array_shift() function removes the first element from an array and returns it. It's like taking the first person out of a waiting line.

$customer_queue = ["Alice", "Bob", "Charlie", "David"];
$current_customer = array_shift($customer_queue);
echo "Now serving: " . $current_customer; // Outputs: Now serving: Alice
print_r($customer_queue);
// Outputs: Array ( [0] => Bob [1] => Charlie [2] => David )

Real-world application: In a job queue system, use array_shift() to remove and process the oldest job first (FIFO - First In, First Out).

array_merge() - Combining Arrays

The array_merge() function combines two or more arrays into a single array. It's like pouring the contents of multiple containers into one larger container.

$frontend_skills = ["HTML", "CSS", "JavaScript"];
$backend_skills = ["PHP", "MySQL", "Node.js"];

$all_skills = array_merge($frontend_skills, $backend_skills);
print_r($all_skills);
// Outputs: Array ( [0] => HTML [1] => CSS [2] => JavaScript 
//                  [3] => PHP [4] => MySQL [5] => Node.js )

// With associative arrays - note that same keys will be overwritten
$default_settings = [
    "theme" => "light",
    "notifications" => true,
    "language" => "en"
];

$user_settings = [
    "theme" => "dark",
    "auto_save" => true
];

$merged_settings = array_merge($default_settings, $user_settings);
print_r($merged_settings);
// Outputs: Array ( [theme] => dark [notifications] => true 
//                  [language] => en [auto_save] => true )

Real-world application: When building a WordPress theme, use array_merge() to combine default theme settings with user-customized settings.

array_combine() - Creating Key-Value Pairs

The array_combine() function creates a new array using one array for keys and another for values. It's like taking two separate lists - one of labels and one of items - and pairing them together.

$countries = ["USA", "Canada", "UK", "Australia"];
$capitals = ["Washington D.C.", "Ottawa", "London", "Canberra"];

$country_capitals = array_combine($countries, $capitals);
print_r($country_capitals);
// Outputs: Array ( [USA] => Washington D.C. [Canada] => Ottawa 
//                  [UK] => London [Australia] => Canberra )

Real-world application: When processing form data, use array_combine() to map form field names to their submitted values for easier processing.

array_slice() - Extracting a Portion of an Array

The array_slice() function extracts a portion of an array starting at a specified position. It's like cutting out a section from a long list.

$months = ["January", "February", "March", "April", "May", "June", 
          "July", "August", "September", "October", "November", "December"];

// Get summer months (starting from index 5, get 3 elements)
$summer_months = array_slice($months, 5, 3);
print_r($summer_months);
// Outputs: Array ( [0] => June [1] => July [2] => August )

// Get last quarter (starting from index 8)
$last_quarter = array_slice($months, 8);
print_r($last_quarter);
// Outputs: Array ( [0] => September [1] => October [2] => November [3] => December )

// Using negative offset to count from the end
$last_two_months = array_slice($months, -2);
print_r($last_two_months);
// Outputs: Array ( [0] => November [1] => December )

Real-world application: When implementing pagination for a blog, use array_slice() to extract just the posts needed for the current page from the full list of posts.

array_splice() - Removing and Replacing Elements

The array_splice() function removes and replaces elements from an array. It's like surgical editing of a list - cutting out sections and optionally inserting new content in their place.

$project_phases = ["Planning", "Design", "Development", "Testing", "Deployment", "Maintenance"];

// Remove phases and save them
$development_phases = array_splice($project_phases, 2, 2);
print_r($development_phases);
// Outputs: Array ( [0] => Development [1] => Testing )

print_r($project_phases);
// Outputs: Array ( [0] => Planning [1] => Design [2] => Deployment [3] => Maintenance )

// Remove and replace
$schedule = ["Monday", "Tuesday", "Thursday", "Friday"];
array_splice($schedule, 2, 0, ["Wednesday"]); // Insert without removing
print_r($schedule);
// Outputs: Array ( [0] => Monday [1] => Tuesday [2] => Wednesday [3] => Thursday [4] => Friday )

Real-world application: In a content management system, use array_splice() to update a section of a document while preserving the rest of the content structure.

Array Transformation Functions

These functions help you reshape and transform your data - like tools that convert raw materials into finished products.

array_map() - Applying a Function to Each Element

The array_map() function applies a callback function to each element of an array and returns a new array with the results. It's like an assembly line that performs the same operation on each item that passes through it.

// Apply a simple transformation
$numbers = [1, 2, 3, 4, 5];
$squared = array_map(function($n) {
    return $n * $n;
}, $numbers);
print_r($squared);
// Outputs: Array ( [0] => 1 [1] => 4 [2] => 9 [3] => 16 [4] => 25 )

// Format strings
$names = ["john doe", "jane smith", "robert johnson"];
$formatted_names = array_map(function($name) {
    return ucwords($name); // Capitalize each word
}, $names);
print_r($formatted_names);
// Outputs: Array ( [0] => John Doe [1] => Jane Smith [2] => Robert Johnson )

// Using arrow functions (PHP 7.4+)
$prices = [9.99, 19.99, 29.99, 39.99];
$discounted_prices = array_map(fn($price) => $price * 0.8, $prices);
print_r($discounted_prices);
// Outputs: Array ( [0] => 7.992 [1] => 15.992 [2] => 23.992 [3] => 31.992 )

Real-world application: When displaying product data from a database, use array_map() to format prices, capitalize product names, or convert timestamps to readable dates before rendering them on a page.

array_filter() - Filtering Array Elements

The array_filter() function filters elements of an array using a callback function. It's like a sieve that only lets certain items pass through based on specific criteria.

// Filter out odd numbers
$numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
$even_numbers = array_filter($numbers, function($n) {
    return $n % 2 === 0;
});
print_r($even_numbers);
// Outputs: Array ( [1] => 2 [3] => 4 [5] => 6 [7] => 8 [9] => 10 )

// Filter out empty strings and nulls
$user_inputs = ["apple", "", null, "banana", "0", 0, false, "cherry"];
$valid_inputs = array_filter($user_inputs);
print_r($valid_inputs);
// Outputs: Array ( [0] => apple [3] => banana [4] => 0 [6] => cherry )

// Filter an associative array
$products = [
    ["name" => "Laptop", "price" => 999, "in_stock" => true],
    ["name" => "Headphones", "price" => 99, "in_stock" => false],
    ["name" => "Keyboard", "price" => 59, "in_stock" => true],
    ["name" => "Monitor", "price" => 299, "in_stock" => true]
];

$in_stock_products = array_filter($products, function($product) {
    return $product["in_stock"] === true;
});
print_r($in_stock_products);

Real-world application: In an e-commerce website, use array_filter() to show only products that are in stock or within a certain price range based on user filters.

array_reduce() - Reducing an Array to a Single Value

The array_reduce() function applies a callback function to the elements of an array to reduce it to a single value. It's like a funnel that combines multiple inputs into one output.

// Sum all numbers
$numbers = [1, 2, 3, 4, 5];
$sum = array_reduce($numbers, function($carry, $item) {
    return $carry + $item;
}, 0);
echo $sum; // Outputs: 15

// Calculate the total price of items in a cart
$cart_items = [
    ["name" => "Laptop", "price" => 999, "quantity" => 1],
    ["name" => "Mouse", "price" => 25, "quantity" => 2],
    ["name" => "Keyboard", "price" => 59, "quantity" => 1]
];

$total_price = array_reduce($cart_items, function($carry, $item) {
    return $carry + ($item["price"] * $item["quantity"]);
}, 0);
echo "Total: $" . $total_price; // Outputs: Total: $1108

// Joining strings
$words = ["PHP", "is", "awesome"];
$sentence = array_reduce($words, function($carry, $word) {
    return $carry . ($carry ? " " : "") . $word;
}, "");
echo $sentence; // Outputs: PHP is awesome

Real-world application: In a WordPress plugin that tracks user activity, use array_reduce() to calculate total time spent on the site from multiple session duration records.

array_keys() and array_values() - Extracting Keys and Values

These functions extract all the keys or all the values from an array. It's like separating the labels from the items they label.

$user = [
    "id" => 1001,
    "username" => "johndoe",
    "email" => "john@example.com",
    "active" => true
];

// Get all keys
$fields = array_keys($user);
print_r($fields);
// Outputs: Array ( [0] => id [1] => username [2] => email [3] => active )

// Get all values
$values = array_values($user);
print_r($values);
// Outputs: Array ( [0] => 1001 [1] => johndoe [2] => john@example.com [3] => 1 )

// Common use case: Reset array keys after filtering
$numbers = [10, 25, 3, 42, 8];
$filtered = array_filter($numbers, function($n) {
    return $n > 10;
});
print_r($filtered);
// Outputs: Array ( [1] => 25 [3] => 42 ) - Note the preserved original keys

$filtered_reindexed = array_values($filtered);
print_r($filtered_reindexed);
// Outputs: Array ( [0] => 25 [1] => 42 ) - Reindexed with sequential keys

Real-world application: When building a database query in WordPress, use array_keys() to extract field names from form data to construct the columns part of an INSERT statement.

array_flip() - Exchanging Keys and Values

The array_flip() function exchanges keys with their associated values in an array. It's like turning a dictionary inside out - making the definitions into entries and the entries into definitions.

$country_codes = [
    "US" => "United States",
    "CA" => "Canada",
    "UK" => "United Kingdom",
    "AU" => "Australia"
];

$code_lookup = array_flip($country_codes);
print_r($code_lookup);
// Outputs: Array ( [United States] => US [Canada] => CA 
//                  [United Kingdom] => UK [Australia] => AU )

// Practical example - checking if a value exists in a specific position
$allowed_positions = ["admin", "editor", "contributor"];
$position_map = array_flip($allowed_positions);

$user_position = "editor";
if (isset($position_map[$user_position])) {
    echo "Valid position!";
    echo "Position index: " . $position_map[$user_position]; // Outputs: Position index: 1
}

Real-world application: In a language translation system, use array_flip() to create reverse lookup tables that allow translation in both directions (e.g., English to Spanish and Spanish to English).

Array Sorting Functions

These functions help you organize your array elements in a specific order - like organizing items on shelves in a store by different criteria.

sort() and rsort() - Sorting Arrays

The sort() function sorts an array in ascending order, while rsort() sorts in descending order. It's like arranging items from smallest to largest or vice versa.

// Sorting numbers
$scores = [85, 92, 78, 95, 88];
sort($scores);
print_r($scores);
// Outputs: Array ( [0] => 78 [1] => 85 [2] => 88 [3] => 92 [4] => 95 )

rsort($scores);
print_r($scores);
// Outputs: Array ( [0] => 95 [1] => 92 [2] => 88 [3] => 85 [4] => 78 )

// Sorting strings
$fruits = ["orange", "apple", "banana", "grape"];
sort($fruits);
print_r($fruits);
// Outputs: Array ( [0] => apple [1] => banana [2] => grape [3] => orange )

Real-world application: In a WordPress archive page, use sort() to arrange posts alphabetically by title when the user selects "A-Z" sorting.

asort() and arsort() - Sorting Associative Arrays by Value

The asort() function sorts an associative array by values while preserving key associations. The arsort() function does the same but in descending order. It's like sorting items on shelves while keeping their labels attached.

// Sorting product prices
$products = [
    "laptop" => 999,
    "phone" => 699,
    "tablet" => 499,
    "watch" => 299
];

// Sort by price (ascending)
asort($products);
print_r($products);
// Outputs: Array ( [watch] => 299 [tablet] => 499 [phone] => 699 [laptop] => 999 )

// Sort by price (descending)
arsort($products);
print_r($products);
// Outputs: Array ( [laptop] => 999 [phone] => 699 [tablet] => 499 [watch] => 299 )

Real-world application: In an e-commerce product catalog, use asort() or arsort() to arrange products by price while maintaining the product identifiers as keys.

ksort() and krsort() - Sorting Associative Arrays by Key

The ksort() function sorts an associative array by keys in ascending order, while krsort() sorts by keys in descending order. It's like organizing a filing cabinet alphabetically by folder names.

// Sorting configuration by option name
$config = [
    "timezone" => "UTC",
    "language" => "en",
    "debug_mode" => false,
    "api_key" => "abc123"
];

// Sort by configuration option name (ascending)
ksort($config);
print_r($config);
// Outputs: Array ( [api_key] => abc123 [debug_mode] => [language] => en [timezone] => UTC )

// Sort by configuration option name (descending)
krsort($config);
print_r($config);
// Outputs: Array ( [timezone] => UTC [language] => en [debug_mode] => [api_key] => abc123 )

Real-world application: In a WordPress settings page, use ksort() to display configuration options in alphabetical order for easier navigation.

usort(), uasort(), and uksort() - Custom Sorting

These functions allow you to sort arrays using your own comparison function. It's like creating custom sorting rules for specialized collections.

// Sorting users by last name
$users = [
    ["name" => "John Smith", "age" => 35],
    ["name" => "Jane Doe", "age" => 28],
    ["name" => "Robert Johnson", "age" => 42],
    ["name" => "Lisa Brown", "age" => 31]
];

// Custom sorting by last name
usort($users, function($a, $b) {
    // Extract last names
    $last_name_a = explode(" ", $a["name"])[1];
    $last_name_b = explode(" ", $b["name"])[1];
    
    // Compare last names
    return strcmp($last_name_a, $last_name_b);
});

print_r($users);
// Outputs users sorted by last name: Brown, Doe, Johnson, Smith

// Sorting complex data with uasort (preserves keys)
$movies = [
    "movie1" => ["title" => "The Matrix", "year" => 1999, "rating" => 8.7],
    "movie2" => ["title" => "Inception", "year" => 2010, "rating" => 8.8],
    "movie3" => ["title" => "Interstellar", "year" => 2014, "rating" => 8.6],
    "movie4" => ["title" => "The Dark Knight", "year" => 2008, "rating" => 9.0]
];

// Sort by rating
uasort($movies, function($a, $b) {
    return $b["rating"] <=> $a["rating"]; // Descending order
});

print_r($movies);
// Outputs movies sorted by rating (highest first), preserving the movie1, movie2, etc. keys

Real-world application: In a WordPress plugin for event management, use usort() to sort events by a complex priority calculated from date, importance, and user preferences.

Practical Applications in WordPress Development

Now that we've explored an arsenal of PHP array functions, let's see how they apply specifically to WordPress development. These examples will help bridge the gap between theory and practice.

Handling WordPress Plugin Options

// Merge default plugin settings with user settings
function my_plugin_get_settings() {
    $default_settings = [
        'enable_feature_a' => true,
        'enable_feature_b' => false,
        'cache_ttl' => 3600,
        'api_endpoint' => 'https://api.example.com/v1',
        'debug_mode' => false
    ];
    
    // Get user settings from WordPress database
    $user_settings = get_option('my_plugin_settings', []);
    
    // Merge settings, with user settings taking precedence
    return array_merge($default_settings, $user_settings);
}

// Filter settings to include only valid options
function my_plugin_validate_settings($input) {
    $valid_settings = [];
    $allowed_keys = ['enable_feature_a', 'enable_feature_b', 'cache_ttl', 'api_endpoint', 'debug_mode'];
    
    foreach ($input as $key => $value) {
        if (in_array($key, $allowed_keys)) {
            $valid_settings[$key] = $value;
        }
    }
    
    return $valid_settings;
}

Processing WordPress Custom Post Types

// Retrieve and process custom post type data
function get_featured_portfolio_items() {
    // Get portfolio posts
    $args = [
        'post_type' => 'portfolio',
        'posts_per_page' => -1,
        'meta_query' => [
            [
                'key' => '_is_featured',
                'value' => '1',
                'compare' => '='
            ]
        ]
    ];
    
    $portfolio_query = new WP_Query($args);
    $portfolio_items = [];
    
    if ($portfolio_query->have_posts()) {
        while ($portfolio_query->have_posts()) {
            $portfolio_query->the_post();
            
            // Build portfolio item data
            $item = [
                'id' => get_the_ID(),
                'title' => get_the_title(),
                'excerpt' => get_the_excerpt(),
                'thumbnail' => get_the_post_thumbnail_url(null, 'medium'),
                'url' => get_permalink(),
                'categories' => []
            ];
            
            // Get categories
            $terms = get_the_terms(get_the_ID(), 'portfolio_category');
            if ($terms && !is_wp_error($terms)) {
                $item['categories'] = array_map(function($term) {
                    return [
                        'id' => $term->term_id,
                        'name' => $term->name,
                        'slug' => $term->slug
                    ];
                }, $terms);
            }
            
            $portfolio_items[] = $item;
        }
        wp_reset_postdata();
    }
    
    // Sort by title alphabetically
    usort($portfolio_items, function($a, $b) {
        return strcmp($a['title'], $b['title']);
    });
    
    return $portfolio_items;
}

Building a Navigation Menu Filter

// Filter WordPress navigation menu items
function custom_nav_menu_items($items, $args) {
    // Only modify the main menu
    if ($args->theme_location !== 'primary') {
        return $items;
    }
    
    // Current user role
    $current_user = wp_get_current_user();
    $user_roles = $current_user->ID ? $current_user->roles : ['guest'];
    
    // Filter menu items based on user role
    $filtered_items = array_filter($items, function($item) use ($user_roles) {
        // Get roles that can view this item (stored in custom field)
        $allowed_roles = get_post_meta($item->ID, '_menu_item_roles', true);
        
        // If no restriction is set, everyone can see it
        if (empty($allowed_roles) || !is_array($allowed_roles)) {
            return true;
        }
        
        // Check if user has any of the required roles
        return count(array_intersect($user_roles, $allowed_roles)) > 0;
    });
    
    // Reindex array keys
    return array_values($filtered_items);
}
add_filter('wp_nav_menu_objects', 'custom_nav_menu_items', 10, 2);

Performance Considerations

When working with arrays, especially large ones, performance becomes crucial. Here are some best practices:

Use array_key_exists() vs isset() appropriately:
isset() is generally faster but doesn't check for NULL values, while array_key_exists() is more thorough but slower.
Prefer foreach over array_map() for simple operations:
While array_map() is cleaner, a simple foreach loop can be more performant for basic operations.
Use array_filter() with a key parameter:
In PHP 5.6+, array_filter() accepts a flag to filter by keys or both keys and values, which can be more efficient than writing custom loops.
Be careful with array_merge() on large arrays:
For very large arrays, array_merge() can be memory-intensive. Consider using the + operator for simple merges that don't need to handle duplicate keys specially.
Reuse arrays when possible:
Creating new arrays for each transformation step can consume memory. When working with large datasets, try to modify arrays in place when appropriate.

Homework Assignment

Put your array function knowledge to the test with this practical WordPress-themed assignment:

WordPress Post Category Analyzer

Create a PHP script that:

Takes an array of WordPress posts (provided in the sample data)
Analyzes the categories assigned to each post
Returns statistical information about category usage
Identifies the most and least used categories
Suggests potential category consolidations based on usage patterns

Your solution should use at least 5 different array functions we've covered in this lesson.

// Sample data (simulated WordPress posts)
$posts = [
    [
        'id' => 1,
        'title' => 'Getting Started with WordPress',
        'categories' => ['Beginners', 'Tutorials', 'WordPress Basics']
    ],
    [
        'id' => 2,
        'title' => 'Advanced Custom Fields Tutorial',
        'categories' => ['Advanced', 'Tutorials', 'Plugins']
    ],
    [
        'id' => 3,
        'title' => 'Optimizing WordPress Performance',
        'categories' => ['Advanced', 'Performance', 'Best Practices']
    ],
    [
        'id' => 4,
        'title' => 'WordPress Security Guide',
        'categories' => ['Security', 'Best Practices', 'Tutorials']
    ],
    [
        'id' => 5,
        'title' => 'Building Your First WordPress Theme',
        'categories' => ['Themes', 'Tutorials', 'Beginners']
    ],
    // Add more posts here...
];

// Your solution here
function analyze_post_categories($posts) {
    // 1. Extract all categories
    
    // 2. Count category occurrences
    
    // 3. Find most and least used categories
    
    // 4. Identify potential category consolidations
    
    // 5. Return the analysis results
}

$analysis = analyze_post_categories($posts);
print_r($analysis);

Coming Up Next: Session 6 - PHP Functions

In our next session, we'll be exploring PHP functions in depth - how to create them, use parameters, return values, and build reusable code structures. These concepts will build directly on the array foundations we've established today.

To prepare for the next session, try creating functions that implement some of the array operations we've learned about today!

Course Progress