Als je plugins of thema’s voor WordPress ontwikkelt, is de kans groot dat jeClasses gebruikt om je code op te maken. Vooral als je meer ervaring hebt met ontwikkeling en object-georiënteerd programmeren (OOP).

Wist je dat in WordPress autoloaden met PHP eenvoudig is? Bij autoloading worden Classes automatisch geladen wanneer ze worden aangeroepen. Vrij nuttig, als je het mij vraagt.

ps. Dit gaat niet over het gebruik van Visual Composer om teksten en lay-out aan te passen in WordPress. Composer is een functionaliteit die veel door PHP programmeurs wordt gebruikt.

Wat is objectgeoriënteerd programmeren?

Maar wacht, je gaat veel te snel! Ik ben net begonnen met ontwikkelen. Dus wat in hemelsnaam is objectgeoriënteerd programmeren?

In essentie draait het bij het objectgeoriënteerde programmeren om het gebruik van zogenaamde objecten. Aan objecten kunnen bepaalde gegevens worden gekoppeld. In PHP is dit in de vorm van properties. Daarnaast kunnen objecten bepaalde functies hebben, de zogenaamde methods. Vaak worden deze methods gebruikt om properties te manipuleren.

Bij het programmeren wordt een object vaak vertegenwoordigd door een Class. Laten we een voorbeeld geven in PHP.

<?php
        class Someclass {
            private $property;

            public function __construct() {
                 $this->property = 1;       
            }

            public function getProperty() {
                  return $this->property;
            }

        }

        $class = new Someclass();   // Constructs the class
        echo $class->getProperty(); // Echoes 1

Dus in het bovenstaande voorbeeld hebben we een class genaamd Someclass met een property genaamd $property en de method getProperty. Eigenschappen binnen een klasse zijn toegankelijk met behulp van $this->property.

Door de $class te initiëren met behulp van new Someclass, maken we een nieuw object uit deze klasse. We kunnen dan toegang krijgen tot deze objectmethoden en -eigenschappen zolang ze public zijn.

Als je dit echt leuk vindt, is er een Canadese kerel genaamd Carl Alexander die veel schrijft over object-georiënteerd programmeren. Zijn inleiding tot object-georiënteerd programmeren voor WordPress is een erg goede introductie.

Terug naar autoloading

Maar dat is genoeg introductie! Laten we teruggaan naar het eigenlijke onderwerp van autoloading.

PHP heeft een zeer nuttige functie genaamd autoloading. Elke keer als je een class oproept, wordt deze automatisch wordt geladen met autoloading. Dit is vooral handig als je veel scripts moet toevoegen.

Classes in WordPress zonder autoloading

Zonder autoloading moet je elke klasse handmatig insluiten. Dit is getoond in het onderstaande voorbeeld. Het spreekt voor zich dat als je veel classes gebruikt, je veel handmatig moet insluiten.

<?php   
	include_once('/folder/class.php');
	$class = new Folder\Class();
?>

Classes in WordPress met autoloading

Met autoloading, kan je gewoon een nieuwe class opzetten en deze zal laden. Als je het correct hebt ingesteld, natuurlijk. De volgende code zou automatisch de class insluiten en uitvoeren als je autoloading gebruikt.

<?php
	$class = new Folder\Someclass();

Om het bovenstaande voorbeeld correct te laten werken, moet de class op de juiste manier met de juiste naam worden aangeduid en in de juiste directory worden geplaatst. Namespacing is een PHP functie dat aangeeft tot welke namespace een bepaalde class (en bestand) behoort. Een namespace komt vaak overeen met de opbouw van een map.

So, in the above example, the new Folder\Class would be placed in folder/someclass.php. The given class would then start with indicating the namespace using PHP namespaces. In this case, Folder.

Dus, in het bovenstaande voorbeeld, zou de nieuwe Folder\Someclass in folder/someclass.php geplaatst worden. In het bestand van deze class zelf moet je dan de namespace aangeven. In dit geval is dat Folder.

<?php
	namespace Folder;

        class Someclass {
            public function __construct() {}
        }

Dus hoe zit het met classes die in meerdere mappen zijn geplaatst? Het is vrij eenvoudig: gebruik de namespace volgens de mappenstructuur. Gebruik bijvoorbeeld namespace Folder\Subfolder.

Verschillende normen voor autolading

If you have been looking into autoloading, you may have seen terms such as PSR-0 and PSR-4 before. Now, these terms indicate the standard for how to deal with file paths and namespacing. In other words, how should namespaces and folders be structured accordingly?

Als je jezelf hebt verdiept in autolading, heb je wellicht al termen als PSR-0 en PSR-4 gezien. Deze termen geven de standaard aan voor het omgaan met bestandspaden en namespaces. Met andere woorden, hoe moeten namespaces en mappen worden gestructureerd?

De huidige standaard is PSR-4. Maar wat houdt PSR-4 in? Laten we eens kijken naar ons vorige voorbeeld:

  • Als we de class laden, gebruiken we de namespace en class: new Folder/Someclass().
  • Deze logica lijkt op de mappenstructuur, namelijk folder/someclass.php.
  • In someclass.php gebruiken we namespace Folder in onze eerste regel van codering om aan te geven bij welke namespace het hoort.
NamespaceClassPad
FolderFolder\Someclassfolder/someclass.php

Simpel gezegd gaat PSR-4 hierover: de namespace van een class volgt het pad (met andere woorden, de mappen) waarin een bepaalde class is geplaatst. Er zijn enkele extra regels die je hier kunt bekijken.

Hoe je WordPress autoloading kan instellen

Dus hoe kan je in WordPress class autoloading inschakelen? PHP wordt geleverd met een handige functie genaamd spl_autoload_register. Deze functie wordt gebruikt om nieuwe functies voor autoloading classes te registreren.

Laten we eens kijken naar een basisvoorbeeld. We gaan ervan uit dat dit bestand is geplaatst in het functions.php bestand van een WordPress thema.

<?php
    spl_autoload_register( function($classname) {

    $class      = str_replace( '\\', DIRECTORY_SEPARATOR, strtolower($classname) ); 
    $classpath  = dirname(__FILE__) .  DIRECTORY_SEPARATOR . 'classes' . DIRECTORY_SEPARATOR . $class . '.php';
    
    if ( file_exists( $classpath) ) {
        include_once $classpath;
    }
   
} );

Wat doet het bovenstaande voorbeeld dan?

  1. Wanneer een class met $classname wordt aangeroepen (bijvoorbeeld Folder/Someclass), zal deze class naar kleine letters worden omgezet. Vervolgens zal de schuine streep in deze class worden vervangen door de slash die wordt gebruikt om directories te scheiden (de zogenaamde DIRECTORY_SEPARATOR).
  2. Vervolgens voegt het de map en eventuele voorgaande mappen aan deze class toe, wat resulteert in $classpath. In dit voorbeeld kan $classpath iets zijn als wp-content/thema’s/thema/thema/classes/class/folder/someclass.php

Als we onze voorgaande class Someclass in de classes/folder/someclass.php in je thema hadden gezet, kunnen we nu de nieuwe Folder\Someclass() aanroepen. We hoeven dit dan niet meer handmatig in te sluiten!

Autoload Classes in WordPress en standaarden voor WordPress

Zoals je misschien al gemerkt hebt, hebben we tot nu toe de regels voor het benamen van bestanden in WordPress genegeerd. Voor PHP-klassen dicteert WordPress het gebruik van het voorvoegsel van class vóór de bestandsnaam. Dus in ons voorbeeld eindigen we met folder/class-someclass.php.

Dus hoe kunnen we onze bestaande autoloader aanpassen om te voldoen aan de standaarden van WordPress? We moeten onze mapstructuur op namespace opsplitsen en de class voorvoegsel aan het uiteindelijke bestand toevoegen. Dit is vrij eenvoudig met de explode functie van PHP:

<?php   
    $parts      = explode('\\', $classname);
    $class      = 'class-' . strtolower( array_pop($parts) );
    $folders    = strtolower( implode(DIRECTORY_SEPARATOR, $parts) );
    $classpath     = dirname(__FILE__) .  DIRECTORY_SEPARATOR . 'classes' . DIRECTORY_SEPARATOR . $folders . DIRECTORY_SEPARATOR . $class . '.php';

Autoloading, WordPress & Composer

De echte kracht van het gebruik van autoloading is het gebruik van modules van Composer.

We hebben bijvoorbeeld verschillende scripts voor WordPress geschreven, zoals het WP Custom Fields script en het WP Components script. Met Composer kunnen deze eenvoudig worden opgenomen in een thema of plugin.

In het volgende voorbeeld gaan we ervan uit dat er een nieuw thema wordt ontwikkeld. In de hoofdmap van het thema plaatsen we een bestand met de naam composer.json. Het kan er zo uitzien:

{
    "name": "makeitworkpress/autoloading-demo",
    "description": "Demo for autoloading with WordPress",
    "repositories": [        
        {
            "type": "vcs",
            "url": "https://github.com/makeitworkpress/wp-components.git"
        }       
    ],
    "require": {
        "php": ">=7.0",
        "makeitworkpress/wp-components": "dev-master"
    },
    "homepage": "https://github.com/makeitworkpress/wordpress-autoload-class/"         
}

Dit bestand geeft aan dat het een aangepaste repository van GitHub gaat gebruiken. Na het plaatsen van het bestand moet je het update-commando van Composer in je terminal gebruiken.

  • Als je composer nog niet gebruikt, moet je dit eerst installeren.
  • Ga naar je terminal, en zorg ervoor dat je op de juiste locatie bent (bijvoorbeeld de map van het thema dat je ontwikkelt).
  • Type composer update —prefer dist. Composer zal nu de benodigde modules in een map met de naam vendor laden. Omdat je gebruik maakt van composer update –prefer-dist, zal het alleen de distributie versie van de repository laden, en niet alle .git gerelateerde code.
  • Composer zal automatisch een aantal scripts instellen voor autoloading.

Onze module is nu geïmporteerd! Het volgende wat je wilt doen is het autolading script, dat door Composer is meegeleverd, insluiten en uitvoeren. Voeg de volgende regel toe aan je functions.php in je thema:

/**
 * Uses composer to autoload our vendor modules. 
 * Make sure you are using composer update --prefer dist in your terminal first, so these modules are loaded!
 */
require_once 'vendor/autoload.php';

/**
 * This loads the WP Components module, as it is included in the example...
 */
$components = new MakeitWorkPress\WP_Components\Boot();

Zo makkelijk is het. De modules hoeven nu alleen nog maar opgeroepen te worden. Ze worden dan automatisch geladen.

Klaar! Vragen?

Je hebt de kracht van het autoladen in WordPress benut. Voel je vrij om opmerkingen of vragen hieronder achter te laten. Er is ook een overzicht van de code uit dit artikel beschikbaar op GitHub.