Programmazione orientata agli oggetti in PHP: trasformare lo sviluppo di WordPress

La programmazione orientata agli oggetti (Object-oriented programming, OOP), un importante paradigma del software, è incentrata sugli “oggetti”, istanze di classi che includono dati e comportamenti anziché “azioni”

PHP, noto per lo scripting lato server, trae grandi vantaggi dall’OOP. Questo perché l’OOP supporta il codice modulare e riutilizzabile, rendendolo più facile da mantenere. A sua volta, questo facilita una migliore organizzazione e scalabilità dei progetti di grandi dimensioni.

La padronanza dell’OOP è importante per gli sviluppatori che lavorano con temi, plugin e soluzioni personalizzate di WordPress. In questo articolo spiegheremo cos’è l’OOP in PHP e l’impatto che ha sullo sviluppo di WordPress. Inoltre, vedremo come implementare i principi dell’OOP in PHP.

Prerequisiti

Per seguire le parti pratiche di questo articolo, è necessario avere:

• XAMPP (o simili) per Apache e MySQL
• Un ambiente PHP nella versione 7.4 o superiore
• Un editor di codice, come Visual Studio Code
• Un’installazione di WordPress locale o in hosting web.
• Conoscenza di PHP e WordPress

Vantaggi dell’OOP nello sviluppo PHP

L’OOP migliora significativamente lo sviluppo di PHP migliorando la modularità, la riusabilità, la scalabilità, la manutenibilità e il lavoro di squadra. Organizza il codice PHP dividendolo in oggetti, ognuno dei quali rappresenta una parte specifica dell’applicazione. Utilizzando gli oggetti, è possibile riutilizzare facilmente il codice, risparmiando tempo e riducendo gli errori.

Con queste premesse, analizziamo due vantaggi specifici dell’OOP in PHP, evidenziando come trasforma il processo di sviluppo.

1. Riutilizzabilità e manutenzione del codice

L’OOP in PHP rende semplice il riutilizzo del codice grazie all’ereditarietà e al polimorfismo. Le classi possono utilizzare proprietà e metodi di altre classi. Questo permette di utilizzare il vecchio codice in modi nuovi con poche modifiche.

L’OOP rende anche più facile la cura del codice. L’incapsulamento significa che gli oggetti mantengono i loro dettagli privati e condividono solo ciò che è necessario, utilizzando metodi speciali chiamati getter e setter. Questo approccio aiuta a evitare che le modifiche apportate a una parte dell’applicazione causino problemi ad altre, rendendo il codice più semplice da aggiornare e mantenere.

Inoltre, poiché gli oggetti sono completi da soli, è più facile trovare e risolvere i bug in alcune parti del sistema. Questo migliora la qualità e l’affidabilità del codice in generale.

2. Maggiore chiarezza e struttura

L’OOP rende il codice PHP più pulito e organizzato grazie alle classi e agli oggetti. Le classi agiscono come modelli per gli oggetti, mantenendo tutto ciò che appartiene a un unico posto.

L’OOP consente inoltre alle classi di utilizzare le funzioni di altre classi, evitando così di dover scrivere lo stesso codice più volte. Tutto ciò contribuisce a rendere il codice più pulito, facile da correggere e meglio organizzato.

Il codice chiaro dell’OOP aiuta i team a lavorare meglio insieme. È più facile per tutti capire cosa fa il codice, il che significa meno tempo per spiegare le cose e più tempo per fare il lavoro. Inoltre riduce gli errori, aiutando il progetto a procedere correttamente. Inoltre, quando il codice è pulito e ordinato, i nuovi membri del team possono mettersi al corrente rapidamente.

Implementare l’OOP in PHP

Nell’OOP per PHP, il codice viene organizzato con classi e oggetti, come i progetti e le case. Si creano classi per ogni cosa (come gli utenti o i libri), comprese le loro caratteristiche e le loro azioni. Poi si utilizza l’ereditarietà per creare nuove classi a partire da quelle esistenti, risparmiando tempo grazie alla possibilità di non ripetere il codice. Inoltre, poiché l’incapsulamento mantiene private alcune parti delle classi, il codice è più sicuro.

Le sezioni seguenti spiegano come utilizzare efficacemente i principi OOP nella programmazione PHP. Creiamo un sistema di gestione dei contenuti (CMS) per la gestione degli articoli.

1. Definire una classe con proprietà e metodi

Iniziamo con una classe Article che include le proprietà title, content e status, oltre ai metodi per impostare e visualizzare queste proprietà.

class Article {
    private $title;
    private $content;
    private $status;

    const STATUS_PUBLISHED = 'published';
    const STATUS_DRAFT = 'draft';

    public function __construct($title, $content) {
        $this->title = $title;
        $this->content = $content;
        $this->status = self::STATUS_DRAFT;
    }

    public function setTitle($title) {
        $this->title = $title;
        return $this;
    }

    public function setContent($content) {
        $this->content = $content;
        return $this;
    }

    public function setStatus($status) {
        $this->status = $status;
        return $this;
    }

    public function display() {
        echo "<h2>{$this->title}</h2><p>{$this->content}</p><strong>Status: {$this->status}</strong>";
    }
}

2. Creare oggetti e implementare il concatenamento dei metodi

Creiamo un oggetto articolo e usiamo il concatenamento di metodi per impostare le sue proprietà:

$article = new Article("OOP in PHP", "Object-Oriented Programming concepts.");
$article->setTitle("Advanced OOP in PHP")->setContent("Exploring advanced concepts in OOP.")->setStatus(Article::STATUS_PUBLISHED)->display();

3. Rafforzare l’incapsulamento e l’ereditarietà

Potenziamo l’incapsulamento utilizzando metodi getter e setter e creiamo una classe FeaturedArticle che erediti da Article:

class FeaturedArticle extends Article {
    private $highlightColor = '#FFFF00'; // Default highlight color

    public function setHighlightColor($color) {
        $this->highlightColor = $color;
        return $this;
    }

    public function display() {
        echo "<div> style='background-color: {$this->highlightColor};'>";
        parent::display();
        echo "</div>";
    }
}

$featuredArticle = new FeaturedArticle("Featured Article", "This is a featured article.");
$featuredArticle->setStatus(FeaturedArticle::STATUS_PUBLISHED)->setHighlightColor('#FFA07A')->display();

4. Interfacce e polimorfismo

Definiamo un’interfaccia per i contenuti pubblicabili e implementiamola nella classe Article per dimostrare il polimorfismo:

interface Publishable {
    public function publish();
}

class Article implements Publishable {
    // Existing class code...

    public function publish() {
        $this->setStatus(self::STATUS_PUBLISHED);
        echo "Article '{$this->title}' published.";
    }
}

function publishContent(Publishable $content) {
    $content->publish();
}

publishContent($article);

5. Utilizzare i tratti per un comportamento condiviso

PHP permette di utilizzare i tratti per aggiungere funzioni alle classi senza doverle ereditare da un’altra classe. Utilizzando il codice sottostante, introduciamo un tratto per registrare le attività all’interno del CMS:

trait Logger {
    public function log($message) {
        // Log message to a file or database
        echo "Log: $message";
    }
}

class Article {
    use Logger;

    // Existing class code...

    public function publish() {
        $this->setStatus(self::STATUS_PUBLISHED);
        $this->log("Article '{$this->title}' published.");
    }
}

L’OOP nello sviluppo di WordPress

I principi dell’OOP migliorano notevolmente lo sviluppo di WordPress, in particolare per quanto riguarda la creazione di temi, plugin e widget. Con l’aiuto dell’OOP, possiamo scrivere codice più pulito, scalabile e manutenibile per i nostri siti WordPress.

Questa sezione analizza come applicare l’OOP nello sviluppo di WordPress. Vi forniremo degli esempi che potrete copiare e incollare in un sito WordPress per testarlo.

L’OOP nei temi di WordPress: Registrazione del tipo di post personalizzato

Per dimostrare l’uso dell’OOP nei temi WordPress, creiamo una classe che gestisca la registrazione di un tipo di post personalizzato.

Inseriamo il seguente codice nel file functions.php del tema. I temi si trovano nella directory wp-content/themes.

class CustomPostTypeRegistrar {
    private $postType;
    private $args;

    public function __construct($postType, $args = []) {
        $this->postType = $postType;
        $this->args = $args;
        add_action('init', array($this, 'registerPostType'));
    }

    public function registerPostType() {
        register_post_type($this->postType, $this->args);
    }
}

// Usage
$bookArgs = [
    'public' => true,
    'label'  => 'Books',
    'supports' => ['title', 'editor', 'thumbnail'],
    'has_archive' => true,
];
new CustomPostTypeRegistrar('book', $bookArgs);

Questo codice registra dinamicamente un tipo di post personalizzato book con i suoi dettagli passati attraverso l’array bookArgs. Si può vedere il nuovo tipo di post personalizzato nella barra laterale dell’amministrazione di WordPress con la dicitura Books.

Questo esempio illustra come l’OOP possa incapsulare la funzionalità di registrazione dei tipi di post personalizzati, rendendola riutilizzabile per diversi tipi di post.

OOP nei plugin di WordPress: Gestore di shortcode

Per un esempio di plugin, sviluppiamo una classe che gestisce uno shortcode per visualizzare un messaggio speciale. Possiamo testare questa funzione aggiungendo lo shortcode sottostante a qualsiasi post o pagina.

<?php
/**
* Plugin Name: OOP Shortcode Handler
* Description: Handles a custom shortcode with OOP.
* Version: 1.0
* Author: Name
*/

class OOPShortcodeHandler {
    public function __construct() {
        add_shortcode('oop_message', array($this, 'displayCustomMessage'));
    }

    public function displayCustomMessage($atts) {
        $attributes = shortcode_atts(['message' => 'Hello, this is your OOP     
message!'], $atts);
        return "<div>{$attributes['message']}</div>";
    }
}

new OOPShortcodeHandler();

Salviamo il file my-oop-shortcode-handler.php nella cartella wp-content/plugins. Infine, attiviamo il plugin.

Quindi, nell’editor della pagina o del post, prima di pubblicare o aggiornare, utilizziamo gli shortcode [oop_message] e [oop_message message="Custom Message Here"], come mostrato di seguito:

Dopo aver pubblicato o aggiornato la pagina o il post, vedremo il messaggio che gli shortcode visualizzati denotano.

OOP nei widget di WordPress: widget a contenuto dinamico

L’OOP è utile anche per i widget, incapsulando le loro funzionalità all’interno di classi. Lo stesso nucleo di WordPress utilizza l’OOP per i widget. Qui creiamo un widget personalizzato che permette agli utenti di visualizzare contenuti dinamici con un titolo e un’area di testo.

Aggiungiamo il seguente codice al file functions.php del tema o all’interno di un plugin. Definisce un widget personalizzato che visualizza il messaggio “Hello World From My Custom Widget!”

class My_Custom_Widget extends WP_Widget {

    public function __construct() {
        parent::__construct(
            'my_custom_widget', // Base ID
            'My Custom Widget', // Name
            array('description' => __('A simple custom widget.', 
'text_domain'),) // Args
        );
    }

    public function widget($args, $instance) {
        echo $args['before_widget'];
        if (!empty($instance['title'])) {
            echo $args['before_title'] . apply_filters('widget_title',  
$instance['title']) . $args['after_title'];
        }
        // Widget content
        echo __('Hello World From My Custom Widget!', 'text_domain');
        echo $args['after_widget'];
    }

    public function form($instance) {
        // Form in WordPress admin
    }

    public function update($new_instance, $old_instance) {
        // Processes widget options to be saved
    }
}

function register_my_custom_widget() {
    register_widget('My_Custom_Widget');
}
add_action('widgets_init', 'register_my_custom_widget');

Mentre modifichiamo il tema attivo utilizzando il link Personalizza nell’area Amministrazione, possiamo aggiungere un nuovo widget personalizzato dove necessario.

Utilizzare le classi di WordPress

WordPress mette a disposizione diverse classi che possiamo utilizzare per interagire con le funzionalità principali del CMS. Due di queste classi sono WP_User e WP_Post, che rappresentano rispettivamente gli utenti e i post.

Estendendo l’esempio del plugin WordPress di cui sopra, incorporiamo queste classi per creare uno shortcode che mostri informazioni sull’autore di un post e dettagli sul post stesso.

Salviamo questo file come my-oop-shortcode-handler-extended.php nella cartella wp-content/plugins. Infine, attiviamo il plugin.

<?php
/**
* Plugin Name: Extended OOP Shortcode Handler
* Description: Extends the shortcode handler to display post and author 
information.
* Version: 1.1
* Author: Your Name
*/

class ExtendedOOPShortcodeHandler {
    public function __construct() {
        add_shortcode('post_author_details', array($this,   
'displayPostAuthorDetails'));
    }

    public function displayPostAuthorDetails($atts) {
        global $post; // Accessing the global $post object to get current post  
details

        $attributes = shortcode_atts([
            'post_id' => $post->ID, // Default to the current post ID
        ], $atts);

        $postDetails = get_post($attributes['post_id']); // Getting the WP_Post  
object
        if (!$postDetails) {
            return "Post not found.";
        }

        $authorDetails = new WP_User($postDetails->post_author); // Getting the 
WP_User object

        $output = "<div class='post-author-details'>";
        $output .= "<h2>Author Information</h2>";
        $output .= "<p>Name: " . esc_html($authorDetails->display_name) . 
"</p>";
        $output .= "<h2>Post Information</h2>";
        $output .= "<p>Title: " . esc_html($postDetails->post_title) . "</p>";
        $output .= "<p>Content: " . 
esc_html(wp_trim_words($postDetails->post_content, 20, '...')) . "</p>";
        $output .= "</div>";

        return $output;
    }
}

new ExtendedOOPShortcodeHandler();

In questa versione estesa, abbiamo creato uno shortcode: [post_author_details post_id="1"].

Quando viene aggiunto a un post o a una pagina, visualizza i dettagli sull’autore del post (utilizzando la classe WP_User ) e sul post stesso (utilizzando la classe WP_Post ).

OOP e l’API REST di WordPress

L’API REST di WordPress è un’aggiunta moderna a WordPress che permette di interagire con i dati del sito in modo più programmabile. Sfrutta ampiamente l’OOP, utilizzando classi per definire gli endpoint, le risposte e la gestione delle richieste. Questo rappresenta un chiaro passaggio dalle sue tradizionali radici procedurali all’adozione dell’OOP.

In netto contrasto con i principi dell’OOP, gran parte del nucleo di WordPress, in particolare i suoi primi componenti come l’API dei temi e dei plugin, è scritto in uno stile di programmazione procedurale.

Ad esempio, mentre un approccio procedurale potrebbe manipolare direttamente le variabili globali e affidare i compiti a una sequenza di funzioni, l’OOP nell’API REST incapsula la logica all’interno di classi. Pertanto, metodi specifici all’interno di queste classi gestiscono attività come il recupero, la creazione, l’aggiornamento o la cancellazione dei post.

Questo separa chiaramente i problemi e rende il codice più facile da estendere e da debuggare.

Attraverso le classi che definiscono gli endpoint e gestiscono le richieste, come ad esempio il recupero dei post con una richiesta a GET /wp-json/wp/v2/posts, l’API REST offre un modo strutturato e scalabile per interagire con i dati di WordPress, restituendo risposte in formato JSON.

Sfruttare Kinsta per l’hosting PHP e WordPress

Le soluzioni di hosting di Kinsta aiutano a ottimizzare le applicazioni PHP e a gestire l’hosting WordPress, soddisfacendo le tradizionali configurazioni PHP e le esigenze specifiche di WordPress. Grazie a una solida infrastruttura costruita su tecnologie all’avanguardia come Google Cloud, Kinsta garantisce prestazioni e scalabilità senza precedenti per le applicazioni PHP basate su OOP.

Per i siti WordPress, il servizio di Hosting WordPress specializzato di Kinsta offre funzionalità come gli aggiornamenti automatici, il monitoraggio della sicurezza e il supporto di esperti. Garantisce una gestione senza problemi e prestazioni superiori, rendendolo ideale sia per gli sviluppatori che per le aziende.

Riepilogo

Come abbiamo visto in questo articolo, l’OOP offre una flessibilità, una scalabilità e una manutenibilità senza pari nello sviluppo di PHP e WordPress.

In qualità di fornitore leader di hosting WordPress gestito, Kinsta riconosce questa esigenza e offre soluzioni su misura per supportare gli sviluppatori come voi nelle vostre imprese OOP PHP. Ecco perché le nostre soluzioni di Hosting di Applicazioni e WordPress sono pensate per assistervi nella realizzazione di progetti WordPress performanti, scalabili e basati su OOP.

Provate Kinsta oggi stesso per scoprire come possiamo aiutarvi a costruire siti WordPress di alto livello!

Avete già sperimentato i vantaggi dell’OOP nei vostri progetti? O siete curiosi di sapere come può trasformare il vostro processo di sviluppo? Condividetelo nei commenti qui sotto.