Practical Exercise: WordPress Theme Options Class

Let's create a complete class that uses constructors and destructors in a practical WordPress context:

<?php
/**
 * Theme Options Manager Class
 * 
 * Demonstrates proper use of constructors and destructors for
 * managing theme options in WordPress.
 */
class Theme_Options_Manager {
    // Default options
    private $defaults = [
        'color_scheme' => 'light',
        'font_size' => 'medium',
        'show_sidebar' => true,
        'header_layout' => 'standard'
    ];
    
    // Current options
    private $options = [];
    
    // Has the options been modified?
    private $is_modified = false;
    
    // Cache file for options
    private $cache_file;
    
    /**
     * Constructor: Initialize the options manager
     * 
     * @param array $custom_defaults Optional custom defaults to override standard ones
     */
    public function __construct($custom_defaults = []) {
        // Set up the cache directory
        $upload_dir = wp_upload_dir();
        $cache_dir = $upload_dir['basedir'] . '/theme-cache';
        
        // Create cache directory if it doesn't exist
        if (!file_exists($cache_dir)) {
            wp_mkdir_p($cache_dir);
        }
        
        $this->cache_file = $cache_dir . '/theme-options.json';
        
        // Merge custom defaults with standard defaults
        if (!empty($custom_defaults) && is_array($custom_defaults)) {
            $this->defaults = array_merge($this->defaults, $custom_defaults);
        }
        
        // Try to load from cache first (faster)
        $this->load_from_cache();
        
        // If cache failed, load from database
        if (empty($this->options)) {
            $this->load_from_database();
        }
        
        // If still empty, use defaults
        if (empty($this->options)) {
            $this->options = $this->defaults;
        }
        
        // Register hooks
        add_action('admin_menu', [$this, 'add_options_page']);
        add_action('admin_init', [$this, 'register_settings']);
    }
    
    /**
     * Load options from cache file
     */
    private function load_from_cache() {
        if (file_exists($this->cache_file)) {
            $json = file_get_contents($this->cache_file);
            $cached_options = json_decode($json, true);
            
            if (is_array($cached_options)) {
                $this->options = $cached_options;
                return true;
            }
        }
        
        return false;
    }
    
    /**
     * Load options from WordPress database
     */
    private function load_from_database() {
        $saved_options = get_option('theme_options');
        
        if (is_array($saved_options)) {
            $this->options = array_merge($this->defaults, $saved_options);
            
            // Update cache while we're at it
            $this->update_cache();
            
            return true;
        }
        
        return false;
    }
    
    /**
     * Update the cache file
     */
    private function update_cache() {
        $json = json_encode($this->options);
        @file_put_contents($this->cache_file, $json);
    }
    
    /**
     * Get an option value
     * 
     * @param string $key Option key
     * @param mixed $default Default value if option doesn't exist
     * @return mixed Option value
     */
    public function get($key, $default = null) {
        if (isset($this->options[$key])) {
            return $this->options[$key];
        }
        
        if ($default !== null) {
            return $default;
        }
        
        return isset($this->defaults[$key]) ? $this->defaults[$key] : null;
    }
    
    /**
     * Set an option value
     * 
     * @param string $key Option key
     * @param mixed $value Option value
     * @return bool Success
     */
    public function set($key, $value) {
        // Check if the value is actually different
        if (!isset($this->options[$key]) || $this->options[$key] !== $value) {
            $this->options[$key] = $value;
            $this->is_modified = true;
            return true;
        }
        
        return false;
    }
    
    /**
     * Save options to database
     * 
     * @return bool Success
     */
    public function save() {
        if ($this->is_modified) {
            $result = update_option('theme_options', $this->options);
            
            if ($result) {
                $this->update_cache();
                $this->is_modified = false;
            }
            
            return $result;
        }
        
        return true; // Nothing to save
    }
    
    /**
     * Reset options to defaults
     * 
     * @return bool Success
     */
    public function reset() {
        $this->options = $this->defaults;
        $this->is_modified = true;
        return $this->save();
    }
    
    /**
     * Add theme options page to admin menu
     */
    public function add_options_page() {
        add_theme_page(
            __('Theme Options', 'textdomain'),
            __('Theme Options', 'textdomain'),
            'edit_theme_options',
            'theme-options',
            [$this, 'render_options_page']
        );
    }
    
    /**
     * Register settings for the options page
     */
    public function register_settings() {
        register_setting('theme_options_group', 'theme_options');
        
        add_settings_section(
            'theme_options_section',
            __('Theme Options', 'textdomain'),
            [$this, 'render_section_intro'],
            'theme-options'
        );
        
        // Register fields for each option
        foreach ($this->defaults as $key => $value) {
            add_settings_field(
                'theme_option_' . $key,
                ucwords(str_replace('_', ' ', $key)),
                [$this, 'render_field'],
                'theme-options',
                'theme_options_section',
                ['key' => $key]
            );
        }
    }
    
    /**
     * Render the intro text for the options section
     */
    public function render_section_intro() {
        echo '
' . __('Customize your theme settings below.', 'textdomain') . '
';
    }
    
    /**
     * Render a field based on its type
     */
    public function render_field($args) {
        $key = $args['key'];
        $value = $this->get($key);
        $name = "theme_options[$key]";
        
        switch ($key) {
            case 'color_scheme':
                echo '';
                echo 'Light';
                echo 'Dark';
                echo 'Custom';
                echo '';
                break;
                
            case 'font_size':
                echo '';
                echo 'Small';
                echo 'Medium';
                echo 'Large';
                echo '';
                break;
                
            case 'show_sidebar':
                echo '';
                break;
                
            case 'header_layout':
                echo '';
                echo 'Standard';
                echo 'Centered';
                echo 'Minimal';
                echo '';
                break;
                
            default:
                echo '';
        }
    }
    
    /**
     * Render the options page
     */
    public function render_options_page() {
        ?>
        

            

            

                
                
                
                
                

                    
                        
                    
                
            
        
        reset();
            wp_redirect(admin_url('themes.php?page=theme-options&reset=success'));
            exit;
        }
    }
    
    /**
     * Destructor: Save any unsaved changes
     */
    public function __destruct() {
        // Automatically save any modified options when the object is destroyed
        if ($this->is_modified) {
            $this->save();
        }
    }
}

// Usage example
function mytheme_get_options_manager() {
    static $options_manager = null;
    
    if (null === $options_manager) {
        $options_manager = new Theme_Options_Manager();
    }
    
    return $options_manager;
}

// Get an option
function mytheme_get_option($key, $default = null) {
    return mytheme_get_options_manager()->get($key, $default);
}

// Set an option
function mytheme_set_option($key, $value) {
    return mytheme_get_options_manager()->set($key, $value);
}

// Save options immediately (not waiting for destructor)
function mytheme_save_options() {
    return mytheme_get_options_manager()->save();
}
?>

This example demonstrates:

• A robust constructor that initializes options from multiple sources (cache, database, defaults)
• A destructor that automatically saves changes when the object is destroyed
• Proper integration with the WordPress admin interface
• Caching for performance optimization
• Helper functions to make accessing the class easier from anywhere in the theme