Recursively Merging Arrays

Sometimes you need to merge arrays with nested structures, preserving keys but also merging nested arrays:

<?php
// Function to recursively merge arrays
function array_merge_recursive_distinct(array &$array1, array &$array2) {
    $merged = $array1;
    
    foreach ($array2 as $key => &$value) {
        if (is_array($value) && isset($merged[$key]) && is_array($merged[$key])) {
            $merged[$key] = array_merge_recursive_distinct($merged[$key], $value);
        } else {
            $merged[$key] = $value;
        }
    }
    
    return $merged;
}

// Example usage
$base_config = [
    'database' => [
        'host' => 'localhost',
        'user' => 'root',
        'password' => '',
        'options' => [
            'charset' => 'utf8mb4',
            'collation' => 'utf8mb4_unicode_ci',
        ]
    ],
    'app' => [
        'debug' => false
    ]
];

$custom_config = [
    'database' => [
        'host' => 'db.example.com',
        'options' => [
            'timeout' => 30
        ]
    ],
    'app' => [
        'debug' => true
    ]
];

// Using union operator (non-recursive)
$simple_merge = $custom_config + $base_config;
echo "<h4>Simple Merge with + Operator</h4>";
echo "<pre>";
print_r($simple_merge);
echo "</pre>";
// Note: database.options from base_config is completely overwritten

// Using recursive merge
$recursive_merge = array_merge_recursive_distinct($base_config, $custom_config);
echo "<h4>Recursive Merge</h4>";
echo "<pre>";
print_r($recursive_merge);
echo "</pre>";
// Note: database.options are merged properly
?>

Combining Array Operations

In real-world applications, you often need to combine multiple array operations:

<?php
// Creating a complex filtering and merging operation
function process_products($products, $filter_criteria, $default_fields) {
    // Step 1: Filter products based on criteria
    $filtered_products = array_filter($products, function($product) use ($filter_criteria) {
        foreach ($filter_criteria as $field => $value) {
            if (!isset($product[$field]) || $product[$field] != $value) {
                return false;
            }
        }
        return true;
    });
    
    // Step 2: Fill in missing fields with defaults
    $complete_products = array_map(function($product) use ($default_fields) {
        return $product + $default_fields;
    }, $filtered_products);
    
    return $complete_products;
}

// Sample data
$products = [
    [
        'id' => 1,
        'name' => 'Smartphone',
        'category' => 'electronics',
        'price' => 499.99,
        'stock' => 15
    ],
    [
        'id' => 2,
        'name' => 'Laptop',
        'category' => 'electronics',
        'price' => 999.99,
    ],
    [
        'id' => 3,
        'name' => 'Headphones',
        'category' => 'accessories',
        'price' => 79.99,
        'stock' => 8
    ],
    [
        'id' => 4,
        'name' => 'Running Shoes',
        'category' => 'footwear',
        'stock' => 12
    ]
];

// Filter criteria
$criteria = [
    'category' => 'electronics'
];

// Default fields
$defaults = [
    'stock' => 0,
    'price' => 0,
    'status' => 'active',
    'description' => 'No description available'
];

// Process the products
$result = process_products($products, $criteria, $defaults);

echo "<h4>Processed Products</h4>";
echo "<pre>";
print_r($result);
echo "</pre>";
?>

Array Comparison Performance Tips

When working with large arrays, performance considerations become important:

<?php
// Performance tips for array comparison
$large_array1 = array_fill(0, 1000, 'value');
$large_array2 = array_fill(0, 1000, 'value');
$large_array2[500] = 'different value';

// Tip 1: Quick comparison with array_diff for simple arrays
function quick_array_compare($array1, $array2) {
    // If array lengths differ, they're definitely not equal
    if (count($array1) !== count($array2)) {
        return false;
    }
    
    // Check if there are any differences (keys or values)
    return empty(array_diff($array1, $array2)) && empty(array_diff($array2, $array1));
}

// Tip 2: Early exit for identity comparison
function quick_identity_check($array1, $array2) {
    // If array lengths differ, they're definitely not identical
    if (count($array1) !== count($array2)) {
        return false;
    }
    
    // Check each element for identity
    foreach ($array1 as $key => $value) {
        if (!array_key_exists($key, $array2) || $array2[$key] !== $value) {
            return false;
        }
    }
    
    return true;
}

// Tip 3: Hash comparison for large arrays
function hash_array_compare($array1, $array2) {
    return md5(serialize($array1)) === md5(serialize($array2));
}

// Example timing
$start_time = microtime(true);
$result1 = ($large_array1 === $large_array2);
$time1 = microtime(true) - $start_time;

$start_time = microtime(true);
$result2 = quick_identity_check($large_array1, $large_array2);
$time2 = microtime(true) - $start_time;

$start_time = microtime(true);
$result3 = hash_array_compare($large_array1, $large_array2);
$time3 = microtime(true) - $start_time;

echo "<h4>Performance Comparison</h4>";
echo "Standard === operator: " . ($result1 ? 'true' : 'false') . " (took " . number_format($time1 * 1000, 4) . " ms)<br>";
echo "Quick identity check: " . ($result2 ? 'true' : 'false') . " (took " . number_format($time2 * 1000, 4) . " ms)<br>";
echo "Hash comparison: " . ($result3 ? 'true' : 'false') . " (took " . number_format($time3 * 1000, 4) . " ms)<br>";
?>

Note: Performance characteristics can vary significantly based on array size, complexity, and PHP version. Always test your specific use case.