Als je plugins of thema's voor WordPress ontwikkelt, is de kans groot dat je Klassen gebruikt om je code op te maken, zeker als je meer ervaring hebt met ontwikkeling en object-georiënteerd programmeren (OOP). En wist je dat in WordPress het autoloaden van klassen met PHP mogelijk is? Met autoloading worden klassen automatisch geladen als ze aangeroepen worden. Best handig, als je het mij vraagt.

Maar wacht, wat is object-georiënteerd programmeren?

Maar wacht, je gaat veel te snel! Ik ben net begonnen met ontwikkelen. Wat is in hemelsnaam object-georiënteerd programmeren?

In essentie draait object-georiënteerd programmeren om het gebruik van zogenaamde objecten. Objecten kunnen bepaalde gegevens aan zich hebben hangen. In PHP is dat in de vorm van eigenschappen. Bovendien kunnen objecten bepaalde functies hebben, die methoden genoemd worden. Vaak worden deze methoden gebruikt om eigenschappen te manipuleren.

In programmeren wordt een object vaak voorgesteld door een klasse. Laten we een voorbeeld geven in PHP.

property = 1;
            }

            publieke functie getProperty() {
                  geef $this->eigendom terug;
            }

        }

        $class = nieuwe Someclass(); // Construeert de klasse
        echo $class->getProperty(); // Echo's 1

In het bovenstaande voorbeeld hebben we dus een klasse die heet Someclass met een eigenschap die $property heet en de methode getProperty. Eigenschappen binnen een klasse worden benaderd door $this->property te gebruiken.

Door de $-klasse te initiëren met nieuwe Someclass, construeren we een nieuw object uit deze klasse. We hebben dan toegang tot de methoden en eigenschappen van dit object, zolang ze publiek zijn.

Als je dit nu echt leuk vindt, is er een Canadese kerel, Carl Alexander genaamd, die veel schrijft over object-georiënteerd programmeren. Misschien wil je eens lezen deze inleiding tot object-georiënteerd programmeren voor WordPress.

Ook als je een beetje nieuw bent met PHP, raad ik je aan eens te kijken naar deze inleiding tot PHP, die je stap voor stap alle grondbeginselen leert.

Terugkomend op automatisch laden

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

Nu komt PHP met een heel handige functie die autoloading heet. Wat het in feite betekent is dat telkens als je een klasse aanroept, die automatisch geladen wordt. Dit is vooral handig als je veel bibliotheken of scripts moet insluiten.

Klassen aanroepen in WordPress zonder autoloading

Zonder autoloading moet je elke klasse handmatig vereisen of includen, zoals in het voorbeeld hieronder. Het is duidelijk dat als je veel klassen gebruikt, je veel include verklaringen nodig hebt.

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

Klassen aanroepen in WordPress met autoloading

Met autoloading kun je de klasse gewoon aanroepen en hij laadt. Mits je het goed ingesteld hebt, natuurlijk. De volgende code zou automatisch de gegeven klasse opnemen en uitvoeren als je autoloading gebruikt zou hebben.

<? php
	$class = nieuwe MapjeSomeclass();

Om het bovenstaande voorbeeld goed te laten werken moet de klasse op de juiste manier namespaced zijn en in de juiste directory geplaatst zijn. Namespacing is een PHP hulpmiddel dat aangeeft tot welke namespace een gegeven klasse (en bestand) behoort. Een namespace komt vaak overeen met de opbouw van een directory.

In het bovenstaande voorbeeld zou dus de nieuwe map/someclass in map/someclass.php geplaatst worden. De gegeven klasse zou dan beginnen met het aangeven van de namespace met behulp van PHP naamruimtes. In dit geval is Map.

<?php
	namespace Map;

        klasse Someclass {}
            publieke functie __construct() {}
        }

Wat nu met klassen die in mappen met meerdere mappen staan? Dat is vrij eenvoudig: geef gewoon namespace volgens de mappenstructuur. Gebruik bijvoorbeeld namespace FolderSubfolder.

Verschillende normen voor autoloading

Als je je verdiept hebt in autoloading, heb je misschien termen gezien als PSR-0 en PSR-4 voor. Nu geven deze termen de standaard aan voor hoe je met bestandspaden en namespacing moet omgaan. Met andere woorden, hoe moeten namespaces en mappen dienovereenkomstig gestructureerd worden?

De huidige norm is PSR-4, dus gelukkig hoeven we alleen in deze norm te duiken. Wat houdt PSR-4 nu eigenlijk in? Laten we naar ons vorige voorbeeld kijken:

  • Als we de klasse aanroepen, gebruiken we de namespace en class: new Map/Someclass()
  • Deze logica lijkt op de mappenstructuur, namelijk map/someclass.php
  • In someclass.php gebruiken we naamruimte Map in onze eerste coderingsregel om aan te geven tot welke namespace het behoort.
NamespaceKlasse NaamPad
MapMapjemap/someclass.php

In een heel basale vorm gaat het hier om PSR-4: de naamruimte van een klasse volgt het pad (met andere woorden, de mappen of directories) waarin een gegeven klasse geplaatst is. Er zijn enkele aanvullende regels die je kan hier inspecteren.

Hoe WordPress autoloading instellen

Dus hoe kun je WordPress class autoloading inschakelen? PHP komt met een handige functie genaamd spl_autoload_register die gebruikt wordt om nieuwe functies voor autoloading klassen te registreren. Laten we eens kijken naar een basisvoorbeeld. We nemen aan dat dit bestand geplaatst is in het functies.php bestand van ons WordPress thema.

<?php
    spl_autoload_register( functie($classname) {

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

Wat doet het bovenstaande voorbeeld dan wel?

  1. Telkens als een klasse met $klassenaam wordt genoemd (bijvoorbeeld, Folder/Someclass), zal het deze klasse kleine letters geven en elke achterwaartse schuine streep scheiden voor de schuine streep die gebruikt wordt om mappen van elkaar te scheiden.
  2. Vervolgens voegt het de klassenmap en eventuele hogere mappen voor deze klasse toe, wat resulteert in $klassenpad. In dit voorbeeld, $klassenpad kan iets zijn als wp-content/themes/theme/classes/folder/someclass.php

Als we onze vorige klasse hadden toegevoegd Someclass binnen classes/folder/someclass.php in je thema, kunnen we nu aanroepen nieuwe mapje-klas(); zonder het handmatig op te nemen!

Van onze WordPress scripts verzameling, er is ook een gratis WordPress klasse autoloader beschikbaar.

WordPress Autoload Klassen en WordPress Naamgeving Conventies

Nu hebben we, zoals je misschien gemerkt hebt, tot nu toe de WordPress naamgevingsconventies voor klassen genegeerd. Voor PHP klassen dicteert WordPress om het klasse voorvoegsel vóór de bestandsnaam te gebruiken. In ons voorbeeld eindigen we dus met map/klas-sommige klasse.php.

Dus hoe kunnen we onze bestaande autoloader aanpassen om aan de normen van WordPress te voldoen? We moeten onze namespaced mappenstructuur en voeg de klasse- voorvoegsel aan het eigenlijke bestand. Het is vrij eenvoudig met behulp van PHP's explode functie:

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

Autoloading en componist

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

We hebben bijvoorbeeld verschillende scripts voor WordPress geschreven, zoals de WP aangepaste velden script en de WP Componenten script. Met behulp van Composer kunnen deze gemakkelijk in een thema of plugin worden opgenomen.

In het volgende voorbeeld nemen we aan dat een nieuw thema ontwikkeld wordt. Binnen de hoofdmap van het thema plaatsen we een bestand met de naam componist.json. Het kan er als volgt uitzien:

{
    "naam": "makeitworkpress/autoloading-demo",
    "beschrijving": "Demo voor autoloaden met 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. Vanzelfsprekend moet je gebruik de update van Composer commando uit onze terminal.

  • Als je componist nog niet gebruikt hebt, moet je installeer het eerst.
  • Ga naar je terminal, en zorg dat je op de juiste plaats bent (bijvoorbeeld de map van het thema dat je aan het ontwikkelen bent).
  • Type composer update –prefer dist. Composer zal nu de vereiste modules laden in een map met de naam verkoper. Omdat je composer update –prefer-dist, laadt het alleen de distributieversie van het repository en niet alle .git gerelateerde code.
  • Composer zal ook automatisch enkele scripts instellen voor autoloading..

Onze module is geïmporteerd! Het volgende dat je wilt doen is het autoloading script dat door Composer. Voeg dus gewoon de volgende regel toe aan je functions.php:

/**
 * Gebruikt composer om onze vendor modules automatisch te laden.
 * Zorg ervoor dat je eerst composer update --prefer dist in je terminal gebruikt, zodat deze modules geladen worden!
 */
require_once 'vendor/autoload.php';

/**
 * Dit laadt de WP Components module, zoals die in het voorbeeld is opgenomen...
 */
$components = nieuwe MakeitWorkPressProductProduct_Components();

Zo gemakkelijk is het. De leveranciersmodules hoeven nu alleen nog maar aangeroepen te worden en worden automatisch geladen.

Klaar! Vragen?

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