PHP Associative Arrays: Key-Value Data Management

Duration: 30 minutes

Module 2: Arrays and Data Manipulation

Learning Objectives

Master PHP array operations
Work with different array types
Use array functions effectively
Manipulate complex data structures

Introduction to Associative Arrays

Welcome to our session on PHP Associative Arrays! Today, we'll explore a powerful and flexible data structure that forms the backbone of many PHP applications, especially in WordPress development. In our previous session, we discussed indexed arrays, which use numeric indices to access values. Now, we'll dive into associative arrays, which use named keys instead of numeric indices.

Think of associative arrays as a dictionary or a phonebook. Rather than looking up a word by its page number, you look it up by its name. Similarly, in associative arrays, you access data by meaningful keys rather than arbitrary numbers.

What Are Associative Arrays?

An associative array is a collection of key-value pairs, where each value is associated with a specific key. Unlike indexed arrays where keys are integers starting from 0, associative array keys are strings that represent the data they contain.

Visual Representation of an Associative Array

Key Characteristics of PHP Associative Arrays

Readable keys: Keys are meaningful strings that describe the data
No automatic indexing: You must explicitly specify key names
Unordered collection: Elements don't have a guaranteed order (unlike indexed arrays)
Mixed data types: Like indexed arrays, values can be of any type
Unique keys: Each key can appear only once in an array (duplicates overwrite previous values)

Creating Associative Arrays in PHP

PHP provides several ways to create associative arrays. Let's explore each method with practical examples:

Method 1: Using the array() Function

// Creating an associative array of user information
$user = array(
    "name" => "John Doe",
    "email" => "john@example.com",
    "role" => "Administrator",
    "active" => true
);

// Output the array
echo "<pre>";
print_r($user);
echo "</pre>";

Output:

Array
(
    [name] => John Doe
    [email] => john@example.com
    [role] => Administrator
    [active] => 1
)

Method 2: Using Short Array Syntax (PHP 5.4+)

// Creating an associative array with product information
$product = [
    "id" => "PRD-001",
    "name" => "WordPress Theme Pro",
    "price" => 59.99,
    "in_stock" => true,
    "categories" => ["themes", "premium", "responsive"]
];

// Output the array
echo "<pre>";
print_r($product);
echo "</pre>";

Output:

Array
(
    [id] => PRD-001
    [name] => WordPress Theme Pro
    [price] => 59.99
    [in_stock] => 1
    [categories] => Array
        (
            [0] => themes
            [1] => premium
            [2] => responsive
        )
)

Method 3: Creating Empty Arrays and Adding Elements

// Creating an empty array
$settings = [];

// Adding elements to the array
$settings["theme"] = "dark";
$settings["sidebar"] = "right";
$settings["notifications"] = true;
$settings["language"] = "en_US";

// Output the array
echo "<pre>";
print_r($settings);
echo "</pre>";

Output:

Array
(
    [theme] => dark
    [sidebar] => right
    [notifications] => 1
    [language] => en_US
)

Method 4: Mixed Indexed and Associative Arrays

PHP arrays can contain both numeric indices and string keys in the same array:

// Creating a mixed array
$mixedArray = [
    "name" => "Mixed Array Example",
    42,
    "type" => "demonstration",
    "hello world",
    "values" => [1, 2, 3]
];

// Output the array
echo "<pre>";
print_r($mixedArray);
echo "</pre>";

Output:

Array
(
    [name] => Mixed Array Example
    [0] => 42
    [type] => demonstration
    [1] => hello world
    [values] => Array
        (
            [0] => 1
            [1] => 2
            [2] => 3
        )
)

Notice that elements without explicit keys are assigned sequential numeric indices, while elements with explicit keys use those keys. This flexibility makes PHP arrays extremely versatile.

Accessing Associative Array Elements

Once you've created an associative array, you need to access its elements. Unlike indexed arrays where you use numeric indices, you access associative array elements using string keys.

Accessing Individual Elements

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

// Accessing individual elements
echo "Name: " . $user["name"] . "<br>";  // Outputs: Name: John Doe
echo "Email: " . $user["email"] . "<br>";  // Outputs: Email: john@example.com

// Modifying an element
$user["role"] = "Editor";
echo "Updated role: " . $user["role"] . "<br>";  // Outputs: Updated role: Editor

// Adding a new element
$user["last_login"] = "2025-04-25";
echo "Last login: " . $user["last_login"] . "<br>";  // Outputs: Last login: 2025-04-25

Checking for Key Existence

Before accessing a key, it's good practice to check if it exists:

// Check if a key exists using isset()
if (isset($user["name"])) {
    echo "User name is: " . $user["name"] . "<br>";
} else {
    echo "User name is not set.<br>";
}

// Check if a key exists using array_key_exists()
if (array_key_exists("phone", $user)) {
    echo "Phone: " . $user["phone"] . "<br>";
} else {
    echo "Phone number not provided.<br>";
}

// The difference between isset() and array_key_exists() with NULL values
$user["phone"] = null;

echo "Using isset():<br>";
if (isset($user["phone"])) {
    echo "Phone is set.<br>";
} else {
    echo "Phone is not set.<br>";  // This will be output because isset() returns false for NULL values
}

echo "Using array_key_exists():<br>";
if (array_key_exists("phone", $user)) {
    echo "Phone key exists.<br>";  // This will be output because the key exists, even though the value is NULL
} else {
    echo "Phone key does not exist.<br>";
}

Using Default Values with Null Coalescing Operator (PHP 7+)

// Using null coalescing operator for default values
$name = $user["name"] ?? "Guest";
$phone = $user["phone"] ?? "Not provided";
$address = $user["address"] ?? "Address not available";

echo "Name: " . $name . "<br>";  // Outputs: Name: John Doe
echo "Phone: " . $phone . "<br>";  // Outputs: Phone: Not provided
echo "Address: " . $address . "<br>";  // Outputs: Address: Address not available

Associative Array Operations and Manipulations

Adding and Updating Elements

$blogPost = [
    "title" => "Getting Started with PHP",
    "author" => "Jane Smith",
    "date" => "2025-04-20"
];

// Add a new element
$blogPost["comments"] = 5;

// Update an existing element
$blogPost["title"] = "Getting Started with PHP Associative Arrays";

// Add multiple elements at once (using array_merge)
$additionalInfo = [
    "category" => "Programming",
    "tags" => ["PHP", "Arrays", "Beginner"],
    "views" => 120
];

$blogPost = array_merge($blogPost, $additionalInfo);

echo "<pre>";
print_r($blogPost);
echo "</pre>";

Removing Elements

$settings = [
    "theme" => "dark",
    "sidebar" => "right",
    "notifications" => true,
    "language" => "en_US",
    "beta_features" => true,
    "old_setting" => "deprecated"
];

// Remove a single element
unset($settings["old_setting"]);

// Remove multiple elements
unset($settings["beta_features"], $settings["notifications"]);

echo "<pre>";
print_r($settings);
echo "</pre>";

Merging Associative Arrays

$defaultSettings = [
    "theme" => "light",
    "sidebar" => "left",
    "notifications" => false,
    "language" => "en_US",
    "font_size" => "medium"
];

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

// Merge with user settings overriding defaults
$activeSettings = array_merge($defaultSettings, $userSettings);

echo "<h4>Active Settings (user overrides defaults):</h4>";
echo "<pre>";
print_r($activeSettings);
echo "</pre>";

// Merge with defaults overriding user settings (rarely used)
$forcedDefaults = array_merge($userSettings, $defaultSettings);

echo "<h4>Forced Default Settings (defaults override user):</h4>";
echo "<pre>";
print_r($forcedDefaults);
echo "</pre>";

Using the + Operator for Array Union

$defaultSettings = [
    "theme" => "light",
    "sidebar" => "left",
    "notifications" => false,
    "language" => "en_US",
    "font_size" => "medium"
];

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

// Using + operator (only adds keys that don't exist)
$mergedSettings = $userSettings + $defaultSettings;

echo "<h4>Settings with + operator (only adds missing keys):</h4>";
echo "<pre>";
print_r($mergedSettings);
echo "</pre>";

The + operator only adds elements from the right array if the key doesn't already exist in the left array. This is different from array_merge(), which replaces values for existing keys.

Iterating Through Associative Arrays

Processing each element in an associative array is a common operation. PHP provides several ways to iterate through associative arrays:

Diagram

Using Foreach Loops (Recommended)

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

// Simple foreach loop (values only)
echo "<h4>User Information:</h4>";
echo "<ul>";
foreach ($user as $value) {
    echo "<li>" . $value . "</li>";
}
echo "</ul>";

// Foreach loop with key and value (most useful for associative arrays)
echo "<h4>User Information with Keys:</h4>";
echo "<ul>";
foreach ($user as $key => $value) {
    // Convert boolean values to Yes/No for display
    if (is_bool($value)) {
        $value = $value ? 'Yes' : 'No';
    }
    echo "<li><strong>" . ucfirst($key) . ":</strong> " . $value . "</li>";
}
echo "</ul>";

Using While Loop with each() (Deprecated in PHP 7.2+)

/* 
 * Note: This method is deprecated in PHP 7.2+ and removed in PHP 8.0
 * It's shown here for historical context and legacy code understanding
 */

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

// Reset the array pointer to the beginning
reset($user);

echo "<h4>User Information (legacy each() method):</h4>";
echo "<ul>";
// This code will work in PHP 7.1 and earlier
while (list($key, $value) = each($user)) {
    echo "<li><strong>" . ucfirst($key) . ":</strong> " . $value . "</li>";
}
echo "</ul>";

// Modern equivalent using foreach
reset($user); // Reset the array pointer again
echo "<h4>User Information (modern foreach equivalent):</h4>";
echo "<ul>";
foreach ($user as $key => $value) {
    echo "<li><strong>" . ucfirst($key) . ":</strong> " . $value . "</li>";
}
echo "</ul>";

Using Array Functions for Iteration

$product = [
    "id" => "PRD-001",
    "name" => "WordPress Theme Pro",
    "price" => 59.99,
    "in_stock" => true
];

// Using array_walk
echo "<h4>Product Details using array_walk:</h4>";
echo "<ul>";
array_walk($product, function($value, $key) {
    if (is_bool($value)) {
        $value = $value ? 'Yes' : 'No';
    }
    echo "<li><strong>" . ucfirst($key) . ":</strong> " . $value . "</li>";
});
echo "</ul>";

// Using array_map with array_keys to transform an associative array
$keys = array_keys($product);
$displayValues = array_map(function($key) use ($product) {
    $value = $product[$key];
    if (is_bool($value)) {
        return ucfirst($key) . ": " . ($value ? 'In Stock' : 'Out of Stock');
    }
    return ucfirst($key) . ": " . $value;
}, $keys);

echo "<h4>Product Details using array_map:</h4>";
echo "<ul>";
foreach ($displayValues as $item) {
    echo "<li>" . $item . "</li>";
}
echo "</ul>";

Essential Functions for Associative Arrays

PHP provides several built-in functions specifically designed for working with associative arrays:

Working with Keys and Values

Diagram

Example: Working with Keys and Values

$person = [
    "name" => "Sarah Johnson",
    "occupation" => "Web Developer",
    "skills" => ["PHP", "WordPress", "JavaScript"],
    "years_experience" => 5,
    "freelancer" => true
];

// Get all keys
$keys = array_keys($person);
echo "Keys: " . implode(", ", $keys) . "<br><br>";

// Get all values (as indexed array)
$values = array_values($person);
echo "Values: <pre>";
print_r($values);
echo "</pre>";

// Check if key exists
if (array_key_exists("skills", $person)) {
    echo "Skills: " . implode(", ", $person["skills"]) . "<br>";
}

// PHP 7.3+ features
if (function_exists('array_key_first')) {
    $firstKey = array_key_first($person);
    $lastKey = array_key_last($person);
    echo "First key: " . $firstKey . ", Value: " . $person[$firstKey] . "<br>";
    echo "Last key: " . $lastKey . ", Value: " . ($person[$lastKey] ? 'Yes' : 'No') . "<br>";
}

Filtering and Transforming Associative Arrays

$userData = [
    "username" => "developer123",
    "password" => "hashed_password_here",
    "email" => "dev@example.com",
    "first_name" => "Alex",
    "last_name" => "Morgan",
    "api_key" => "sk_34a5d54d9f8e2",
    "is_admin" => false,
    "last_login" => "2025-04-22"
];

// Filter sensitive data (create a "safe" array for display)
$safeUserData = array_filter($userData, function($key) {
    // List of keys that are safe to display
    $safeKeys = ['username', 'email', 'first_name', 'last_name', 'is_admin', 'last_login'];
    return in_array($key, $safeKeys);
}, ARRAY_FILTER_USE_KEY);

echo "<h4>Safe User Data for Display:</h4>";
echo "<pre>";
print_r($safeUserData);
echo "</pre>";

// Transform keys (e.g., for an API response)
$transformedData = [];
array_walk($userData, function($value, $key) use (&$transformedData) {
    // Convert snake_case keys to camelCase
    $camelKey = lcfirst(str_replace('_', '', ucwords($key, '_')));
    $transformedData[$camelKey] = $value;
});

echo "<h4>Transformed Data (camelCase keys):</h4>";
echo "<pre>";
print_r($transformedData);
echo "</pre>";

Sorting Associative Arrays

$products = [
    "wp_theme" => [
        "name" => "Pro WordPress Theme",
        "price" => 59.99,
        "sales" => 253
    ],
    "plugin_seo" => [
        "name" => "SEO Booster Plugin",
        "price" => 29.99,
        "sales" => 842
    ],
    "plugin_cache" => [
        "name" => "Cache Optimizer",
        "price" => 19.99,
        "sales" => 1205
    ],
    "ebook_wp" => [
        "name" => "WordPress Development Guide",
        "price" => 14.99,
        "sales" => 567
    ]
];

// Sort by value (here we'll sort by price)
// Create a copy for each sort type
$byPrice = $products;

// Sort by price (low to high)
uasort($byPrice, function($a, $b) {
    return $a['price'] <=> $b['price']; // PHP 7+ spaceship operator
});

echo "<h4>Products by Price (Low to High):</h4>";
echo "<pre>";
print_r($byPrice);
echo "</pre>";

// Sort by sales (high to low)
$bySales = $products;
uasort($bySales, function($a, $b) {
    return $b['sales'] <=> $a['sales']; // Note b <=> a for descending order
});

echo "<h4>Products by Sales (High to Low):</h4>";
echo "<pre>";
print_r($bySales);
echo "</pre>";

// Sort by keys (alphabetical)
$productsByKey = $products;
ksort($productsByKey);

echo "<h4>Products by Key (Alphabetical):</h4>";
echo "<pre>";
print_r($productsByKey);
echo "</pre>";

Real-World Applications in WordPress

Example 1: WordPress Post Meta

WordPress stores post meta as key-value pairs, which PHP processes as associative arrays:

// WordPress-like example for handling post meta
function getPostMeta($postId) {
    // In a real WordPress site, this would use get_post_meta()
    // This is a simplified example
    return [
        "_thumbnail_id" => 125,
        "_wp_page_template" => "templates/full-width.php",
        "seo_title" => "PHP Arrays Tutorial | Learn WordPress Development",
        "seo_description" => "Master PHP associative arrays and enhance your WordPress development skills.",
        "views_count" => 1250,
        "featured" => true
    ];
}

$postId = 42; // Example post ID
$postMeta = getPostMeta($postId);

echo "<div class='post-meta-display'>";
echo "<h4>Post Metadata</h4>";
echo "<ul>";

// Display only public meta (keys not starting with _)
foreach ($postMeta as $key => $value) {
    if (strpos($key, '_') !== 0) { // Skip private meta fields (starting with _)
        // Format the display of the meta key
        $displayKey = str_replace('_', ' ', $key);
        $displayKey = ucwords($displayKey);
        
        // Format the value display based on type
        if (is_bool($value)) {
            $displayValue = $value ? 'Yes' : 'No';
        } else {
            $displayValue = $value;
        }
        
        echo "<li><strong>{$displayKey}:</strong> {$displayValue}</li>";
    }
}
echo "</ul>";
echo "</div>";

Example 2: WordPress Options

WordPress stores site options as associative arrays:

// WordPress-like example for theme/plugin options
function getThemeOptions() {
    // In a real WordPress site, this would use get_option()
    // This is a simplified example
    return [
        "theme_color" => "#3498db",
        "logo_url" => "/wp-content/uploads/2025/04/logo.png",
        "show_header" => true,
        "footer_text" => "© 2025 PHP WordPress Development",
        "social_links" => [
            "facebook" => "https://facebook.com/wpdevtraining",
            "twitter" => "https://twitter.com/wpdevtraining",
            "instagram" => "https://instagram.com/wpdevtraining"
        ],
        "sidebar_position" => "right",
        "custom_css" => ".header { padding: 20px; }"
    ];
}

$themeOptions = getThemeOptions();

// Using theme options to configure a page
echo "<div class='theme-options-demo' style='color: {$themeOptions["theme_color"]};'>";
echo "<h4>Theme Configuration</h4>";

// Show header based on option
if ($themeOptions["show_header"]) {
    echo "<div class='header'>";
    echo "<img src='{$themeOptions["logo_url"]}' alt='Logo' />";
    echo "</div>";
}

// Display social links
echo "<div class='social-links'>";
foreach ($themeOptions["social_links"] as $platform => $url) {
    echo "<a href='{$url}'>{$platform}</a> ";
}
echo "</div>";

// Footer text
echo "<div class='footer'>{$themeOptions["footer_text"]}</div>";
echo "</div>";

Example 3: WordPress Query Arguments

WordPress functions like WP_Query use associative arrays for arguments:

// WordPress-like example for building query arguments
function buildPostQuery($categorySlug, $postsPerPage = 5, $featuredOnly = false) {
    $args = [
        "post_type" => "post",
        "posts_per_page" => $postsPerPage,
        "orderby" => "date",
        "order" => "DESC"
    ];
    
    // Add category constraint if provided
    if ($categorySlug) {
        $args["category_name"] = $categorySlug;
    }
    
    // Add featured filter if requested
    if ($featuredOnly) {
        $args["meta_query"] = [
            [
                "key" => "featured",
                "value" => "1",
                "compare" => "="
            ]
        ];
    }
    
    return $args;
}

// Build different query configurations
$allPosts = buildPostQuery(null);
$tutorialPosts = buildPostQuery("tutorials", 10);
$featuredPosts = buildPostQuery(null, 3, true);

// Display the query arguments
echo "<h4>Regular Posts Query:</h4>";
echo "<pre>";
print_r($allPosts);
echo "</pre>";

echo "<h4>Tutorial Posts Query:</h4>";
echo "<pre>";
print_r($tutorialPosts);
echo "</pre>";

echo "<h4>Featured Posts Query:</h4>";
echo "<pre>";
print_r($featuredPosts);
echo "</pre>";

Advanced Topics: Manipulating Complex Associative Arrays

Working with Multidimensional Arrays

WordPress often uses nested associative arrays for complex data:

// Example of a complex WordPress plugin settings structure
$pluginSettings = [
    "general" => [
        "enabled" => true,
        "debug_mode" => false,
        "cache_time" => 3600
    ],
    "display" => [
        "theme" => "modern",
        "show_author" => true,
        "show_date" => true,
        "thumbnail_size" => "medium"
    ],
    "advanced" => [
        "api_keys" => [
            "google" => "AIza123456789",
            "facebook" => "FB123456789",
            "twitter" => "TW123456789"
        ],
        "custom_css" => ".plugin-container { margin: 20px; }",
        "priorities" => [10, 20, 30]
    ]
];

// Accessing nested values
$cacheTime = $pluginSettings["general"]["cache_time"];
$googleApiKey = $pluginSettings["advanced"]["api_keys"]["google"];

echo "Cache Time: " . $cacheTime . " seconds<br>";
echo "Google API Key: " . $googleApiKey . "<br><br>";

// Modifying nested values
$pluginSettings["display"]["thumbnail_size"] = "large";
$pluginSettings["advanced"]["api_keys"]["instagram"] = "IG123456789";

// Checking for nested keys safely
function getNestedValue($array, $path, $default = null) {
    // Split path into segments
    $segments = is_array($path) ? $path : explode('.', $path);
    
    // Reference to current position in the array
    $current = $array;
    
    // Traverse the path
    foreach ($segments as $segment) {
        if (!is_array($current) || !array_key_exists($segment, $current)) {
            return $default;
        }
        $current = $current[$segment];
    }
    
    return $current;
}

// Example usage
$facebookKey = getNestedValue($pluginSettings, 'advanced.api_keys.facebook', 'Not found');
$youtubeKey = getNestedValue($pluginSettings, 'advanced.api_keys.youtube', 'Not found');

echo "Facebook API Key: " . $facebookKey . "<br>";  // Should be found
echo "YouTube API Key: " . $youtubeKey . "<br>";    // Should show "Not found"

Recursive Array Functions

Processing complex nested arrays often requires recursive functions:

// Example dataset: WordPress-like menu structure
$menuStructure = [
    [
        "title" => "Home",
        "url" => "/",
        "children" => []
    ],
    [
        "title" => "About",
        "url" => "/about",
        "children" => [
            [
                "title" => "Our Team",
                "url" => "/about/team",
                "children" => []
            ],
            [
                "title" => "History",
                "url" => "/about/history",
                "children" => []
            ]
        ]
    ],
    [
        "title" => "Services",
        "url" => "/services",
        "children" => [
            [
                "title" => "Web Development",
                "url" => "/services/web-development",
                "children" => [
                    [
                        "title" => "WordPress",
                        "url" => "/services/web-development/wordpress",
                        "children" => []
                    ],
                    [
                        "title" => "E-commerce",
                        "url" => "/services/web-development/ecommerce",
                        "children" => []
                    ]
                ]
            ],
            [
                "title" => "SEO",
                "url" => "/services/seo",
                "children" => []
            ]
        ]
    ],
    [
        "title" => "Contact",
        "url" => "/contact",
        "children" => []
    ]
];

// Recursive function to render a navigation menu
function renderMenu($items, $level = 0) {
    if (empty($items)) {
        return '';
    }
    
    $indent = str_repeat('  ', $level); // Indentation for demonstration
    $html = $indent . "<ul class='menu level-{$level}'>
";
    
    foreach ($items as $item) {
        $html .= $indent . "  <li><a href='{$item['url']}'>{$item['title']}</a>";
        
        // Recursively render children
        if (!empty($item['children'])) {
            $html .= "
" . renderMenu($item['children'], $level + 1) . $indent . "  ";
        }
        
        $html .= "</li>
";
    }
    
    $html .= $indent . "</ul>
";
    return $html;
}

// Render the menu
echo "<h4>Recursive Menu Rendering:</h4>";
echo "<pre>";
echo htmlspecialchars(renderMenu($menuStructure));
echo "</pre>";

// Recursive function to count all menu items
function countMenuItems($items) {
    $count = count($items);
    
    foreach ($items as $item) {
        if (!empty($item['children'])) {
            $count += countMenuItems($item['children']);
        }
    }
    
    return $count;
}

$totalItems = countMenuItems($menuStructure);
echo "Total menu items: " . $totalItems . "<br>";

Array Serialization and JSON Conversion

WordPress often stores associative arrays as serialized data or JSON:

// WordPress plugin settings to store in the database
$pluginConfig = [
    "version" => "2.5.0",
    "activated" => true,
    "user_roles" => ["administrator", "editor"],
    "features" => [
        "social_sharing" => true,
        "comments" => true,
        "analytics" => false
    ],
    "style" => [
        "primary_color" => "#3498db",
        "secondary_color" => "#2ecc71",
        "font_size" => "16px"
    ]
];

// Traditional WordPress way: PHP serialization
$serialized = serialize($pluginConfig);
echo "<h4>Serialized Data (classic WordPress):</h4>";
echo "<pre>";
echo htmlspecialchars($serialized);
echo "</pre>";

// Modern approach: JSON
$json = json_encode($pluginConfig, JSON_PRETTY_PRINT);
echo "<h4>JSON Data (modern WordPress):</h4>";
echo "<pre>";
echo htmlspecialchars($json);
echo "</pre>";

// Retrieving and using the data
echo "<h4>Data Retrieval:</h4>";

// From serialized data
$fromSerialized = unserialize($serialized);
echo "Plugin version (from serialized): " . $fromSerialized["version"] . "<br>";

// From JSON
$fromJson = json_decode($json, true); // true makes it return as associative array
echo "Plugin version (from JSON): " . $fromJson["version"] . "<br>";

// Converting between formats (useful for plugin migrations)
function convertSerializedToJson($serializedData) {
    $array = unserialize($serializedData);
    return json_encode($array);
}

$converted = convertSerializedToJson($serialized);
echo "<h4>Converted from Serialized to JSON:</h4>";
echo "<pre>";
echo htmlspecialchars($converted);
echo "</pre>";

Practical Exercise: Building a WordPress Settings Page

Let's apply what we've learned by creating a simplified version of a WordPress plugin settings page using associative arrays:

// Default plugin settings
$defaultSettings = [
    "general" => [
        "plugin_enabled" => true,
        "debug_mode" => false,
        "user_roles" => ["administrator"]
    ],
    "display" => [
        "theme" => "light",
        "show_title" => true,
        "show_date" => true,
        "items_per_page" => 10
    ],
    "advanced" => [
        "cache_enabled" => true,
        "cache_time" => 3600,
        "custom_css" => ""
    ]
];

// Simulated user-saved settings (normally from database)
$savedSettings = [
    "general" => [
        "plugin_enabled" => true,
        "user_roles" => ["administrator", "editor"]
    ],
    "display" => [
        "theme" => "dark",
        "items_per_page" => 5
    ],
    "advanced" => [
        "custom_css" => ".my-plugin { color: red; }"
    ]
];

// Merge the saved settings with defaults
function mergeSettings($defaults, $saved) {
    $merged = $defaults;
    
    foreach ($saved as $section => $options) {
        if (isset($merged[$section])) {
            foreach ($options as $key => $value) {
                $merged[$section][$key] = $value;
            }
        } else {
            $merged[$section] = $options;
        }
    }
    
    return $merged;
}

// Get the effective settings
$settings = mergeSettings($defaultSettings, $savedSettings);

// Function to render a settings form
function renderSettingsForm($settings) {
    $html = "<form class='settings-form'>
";
    
    foreach ($settings as $section => $options) {
        $html .= "  <div class='settings-section'>
";
        $html .= "    <h3>" . ucfirst($section) . " Settings</h3>
";
        
        foreach ($options as $option => $value) {
            $html .= "    <div class='form-field'>
";
            $html .= "      <label for='{$section}_{$option}'>" . formatLabel($option) . "</label>
";
            
            // Render appropriate input based on value type
            if (is_bool($value)) {
                $checked = $value ? 'checked' : '';
                $html .= "      <input type='checkbox' id='{$section}_{$option}' name='{$section}[{$option}]' {$checked}>
";
            } elseif (is_array($value)) {
                $html .= "      <select id='{$section}_{$option}' name='{$section}[{$option}][]' multiple>
";
                $roles = ["administrator", "editor", "author", "contributor", "subscriber"];
                foreach ($roles as $role) {
                    $selected = in_array($role, $value) ? 'selected' : '';
                    $html .= "        <option value='{$role}' {$selected}>" . ucfirst($role) . "</option>
";
                }
                $html .= "      </select>
";
            } elseif (is_numeric($value)) {
                $html .= "      <input type='number' id='{$section}_{$option}' name='{$section}[{$option}]' value='{$value}'>
";
            } elseif ($option === 'custom_css') {
                $html .= "      <textarea id='{$section}_{$option}' name='{$section}[{$option}]' rows='5'>{$value}</textarea>
";
            } else {
                $html .= "      <input type='text' id='{$section}_{$option}' name='{$section}[{$option}]' value='{$value}'>
";
            }
            
            $html .= "    </div>
";
        }
        
        $html .= "  </div>
";
    }
    
    $html .= "  <button type='submit'>Save Settings</button>
";
    $html .= "</form>";
    
    return $html;
}

// Helper function to format option keys as labels
function formatLabel($key) {
    return ucwords(str_replace('_', ' ', $key));
}

// Display the settings form
echo "<h4>Plugin Settings Form:</h4>";
echo renderSettingsForm($settings);

// Display the effective settings (for demonstration)
echo "<h4>Effective Settings (Merged):</h4>";
echo "<pre>";
print_r($settings);
echo "</pre>";

// Simulate saving settings
echo "<h4>Saving Settings:</h4>";
echo "In a real WordPress plugin, the settings would be saved with:<br>";
echo "<code>update_option('my_plugin_settings', json_encode(\$settings));</code><br>";
echo "And retrieved with:<br>";
echo "<code>\$settings = json_decode(get_option('my_plugin_settings', '{}'), true);</code>";

Best Practices for Working with Associative Arrays

Use descriptive keys: Choose key names that clearly describe their values
Keep consistent formats: Maintain consistent naming conventions for keys (e.g., snake_case or camelCase)
Validate keys before access: Always use isset() or array_key_exists() before accessing associative array elements
Use null coalescing operator: In PHP 7+, use $value = $array['key'] ?? 'default'; for cleaner default value handling
Structure for extensibility: Design arrays with nested structures for related data
Consider memory usage: For large datasets, be mindful of memory consumption
Document complex structures: Add comments explaining the expected structure of complex associative arrays
Prefer foreach loops: Use foreach ($array as $key => $value) for clean iteration
Use recursion for nested arrays: Implement recursive functions to process deeply nested arrays
Merge arrays carefully: Be aware of the differences between array_merge() and the + operator

Homework Assignment: WordPress Plugin Configuration

Create a PHP script that implements a configuration system for a WordPress plugin with the following requirements:

Define a default configuration associative array with at least three sections (general, display, advanced)
Create a function that merges user settings with default settings (preserving defaults for missing options)
Implement a function that validates the configuration (e.g., checks types, ensures required fields exist)
Create a function that renders a settings form based on the configuration array
Implement a function that "saves" the configuration (for this assignment, just output what would be saved)
Create a function that exports the configuration to both a serialized format and a JSON format
Add a section to your script that demonstrates all these functions

Bonus Challenge: Create a recursive validation function that can validate complex nested configurations, including checking field types, required fields, and value constraints (min/max for numbers, allowed values for enums, etc.).

Coming Up Next

In our next session, we'll build on our knowledge of associative arrays to explore:

Multidimensional Arrays: Complex nested data structures
Advanced array iteration techniques
Array sorting with custom comparison functions
Performance optimization for large arrays
Working with JSON and serialized data in WordPress

Course Progress

Learning Objectives

Introduction to Associative Arrays

What Are Associative Arrays?

Visual Representation of an Associative Array

Key Characteristics of PHP Associative Arrays

Creating Associative Arrays in PHP

Method 1: Using the array() Function

Method 2: Using Short Array Syntax (PHP 5.4+)

Method 3: Creating Empty Arrays and Adding Elements

Method 4: Mixed Indexed and Associative Arrays

Accessing Associative Array Elements

Accessing Individual Elements

Checking for Key Existence

Using Default Values with Null Coalescing Operator (PHP 7+)

Associative Array Operations and Manipulations

Adding and Updating Elements

Removing Elements

Merging Associative Arrays

Using the + Operator for Array Union

Iterating Through Associative Arrays

Using Foreach Loops (Recommended)

Using While Loop with each() (Deprecated in PHP 7.2+)

Using Array Functions for Iteration

Essential Functions for Associative Arrays

Working with Keys and Values

Example: Working with Keys and Values

Filtering and Transforming Associative Arrays

Sorting Associative Arrays

Real-World Applications in WordPress

Example 1: WordPress Post Meta

Example 2: WordPress Options

Example 3: WordPress Query Arguments

Advanced Topics: Manipulating Complex Associative Arrays

Working with Multidimensional Arrays

Recursive Array Functions

Array Serialization and JSON Conversion

Practical Exercise: Building a WordPress Settings Page

Best Practices for Working with Associative Arrays

Homework Assignment: WordPress Plugin Configuration

Further Reading and Resources

Coming Up Next