Prelude

WordPress is a popular content management system (CMS) that powers over 40% of all websites on the internet. It was primarily built with a focus on functional programming, which is a programming paradigm that emphasizes writing programs using only functions and avoiding changing state and mutable data. However, Object-Oriented Programming (OOP) has also found its way into WordPress development, and it brings with it numerous benefits.

One of the main advantages of using OOP in WordPress development is that it makes code modular and reusable. OOP allows developers to create classes and objects that can be used across different projects and can be easily modified without affecting other parts of the codebase. This means that plugins, themes, and other customizations can be built faster and with less code, making them more efficient and easier to maintain.

Another benefit of OOP in WordPress is that it promotes encapsulation, which means that data and functionality are kept together in one place. This makes it easier to manage and understand the codebase, as well as making it easier to debug and fix errors.

Let’s have a look at an example, shall we?

Say we want to create a plugin that displays the weather on the homepage of our website. We can create a class called ‘Weather’ that contains all the data and functionality we need, including the weather API key, the location, and the method to fetch the weather data. We can then create an object of the ‘Weather’ class, which we can use to display the weather on the homepage.

Class Weather {
    private $api_key = 'your_api_key_here';
    private $location = 'New York';

    public function get_weather_data() {
        // Call weather API and get data
        $weather_data = // code to fetch weather data using $api_key and $location
        return $weather_data;
    }
}

$weather = new Weather();
$weather_data = $weather->get_weather_data();

// Display weather data on homepage
echo 'The temperature in ' . $weather->location . ' is ' . $weather_data['temperature'] . '°C.';

As you might be thinking, “Arne, that’s just an OOP class you created. How can I integrate that with WordPress?” Well, let me give you a glimpse of how it works in practice.

WordPress development involves more than just creating classes and objects. WordPress uses hooks and filters almost everywhere, making it easier to customize and extend the platform’s functionality. Hooks are actions or filters that allow developers to add, modify, or remove functionality from WordPress without modifying the core codebase.

The real WordPress way – This is the way!

For example, let’s say we want to extend our ‘Weather’ class to display the weather on the WordPress dashboard. We can do this by creating a function that hooks into the ‘wp_dashboard_setup’ action and adds a widget that displays the weather. Here’s how we can modify our ‘Weather’ class to add this functionality:

Class Weather {
    private $apiKey = 'your_api_key_here';
    private $location = 'New York';

    public function __construct() {
        add_action('init', [$this, 'addDashboardWidget']);
    }

    public function addDashboardWidget() {
        wp_add_dashboard_widget(
            'weather_dashboard_widget',
            'Weather',
            array( $this, 'displayWeatherWidget' )
        );
    }

    public function displayWeatherWidget() {
        $weatherData = $this->getWeatherData();
        echo 'The temperature in ' . $this->location . ' is ' . $weatherData['temperature'] . '°C.';
    }

    public function getWeatherData() {
        // Call weather API and get data
        $weatherData = // code to fetch weather data using $apiKey and $location
        return $weatherData;
    }
}

In this example, we’ve added two new methods to our Weather class: addDashboardWidget and displayWeatherWidget. The addDashboardWidget method hooks into the wp_dashboard_setup action and adds a widget that displays the weather. The displayWeatherWidget method gets the weather data using the getWeatherData method and displays it on the widget.
Notice how everything starts from the constructor; in there we fire addDashboardWidget on the init hook.As a quick little bonus, you might have noticed that we use a specific syntax to call our callbacks: add_action('init', [$this, 'addDashboardWidget']). The reason for this is that in class-based syntax, we can’t just use strings. add_action('init', 'addDashboardWidget') won’t work because the interpreter won’t know which 'addDashboardWidget' method to call. To avoid this, we bind $this, which refers to the current class, making it clear which method to call. This approach is not only necessary but also pretty neat, making OOP in WordPress all the more powerful.