[ad_1]
Object-georiënteerd programmeren / object oriented programming (OOP), een belangrijk paradigma in software, draait om “objecten” – instanties van klassen die gegevens en gedragingen bevatten in plaats van “acties”.
PHP, bekend om server-side scripting, heeft veel baat bij OOP. Dit komt omdat OPP modulaire en herbruikbare code ondersteunt, waardoor deze makkelijker te onderhouden is. Dit vergemakkelijkt weer een betere organisatie en schaalbaarheid van grote projecten.
Het beheersen van OOP is belangrijk voor ontwikkelaars die werken met WordPress thema’s, plugins en aangepaste oplossingen. In dit artikel beschrijven we wat OOP in PHP is en welke invloed het heeft op de ontwikkeling van WordPress. We laten je ook zien hoe je OOP principes in PHP kunt implementeren.
Vereisten
Om de praktische delen van dit artikel te kunnen volgen, moet je ervoor zorgen dat je beschikt over:
Voordelen van OOP in PHP ontwikkeling
OOP verbetert de ontwikkeling van PHP aanzienlijk door modulariteit, herbruikbaarheid, schaalbaarheid, onderhoudbaarheid en teamwork te verbeteren. Het organiseert PHP code door het op te delen in objecten, die elk een specifiek deel van de applicatie vertegenwoordigen. Door objecten te gebruiken kun je eenvoudig code hergebruiken, wat tijd bespaart en fouten vermindert.
Laten we met dit in gedachten eens duiken in twee specifieke voordelen van OOP in PHP, waarbij we benadrukken hoe het het ontwikkelproces transformeert.
1. Herbruikbaarheid en onderhoud van code
OOP in PHP maakt het eenvoudig om code te hergebruiken dankzij inheritance en polymorfisme. Klassen kunnen properties en methoden van andere klassen gebruiken. Hierdoor kun je oude code met weinig aanpassingen op nieuwe manieren gebruiken.
OOP maakt het ook gemakkelijker om voor je code te zorgen. Encapsulatie betekent dat objecten hun details privé houden en alleen delen wat nodig is, met behulp van speciale methoden die getters en setters worden genoemd. Deze aanpak helpt voorkomen dat veranderingen in een deel van je applicatie problemen veroorzaken in andere delen, waardoor de code eenvoudiger bij te werken en te onderhouden is.
Omdat objecten volledig op zichzelf staan, is het ook eenvoudiger om bugs in bepaalde delen van het systeem te vinden en te repareren. Dit verbetert de algehele kwaliteit en betrouwbaarheid van de code.
2. Verbeterde duidelijkheid en structuur
OOP maakt PHP code schoner en overzichtelijker met behulp van klassen en objecten. Klassen werken als templates voor objecten en houden alles wat bij elkaar hoort op één plaats.
Met OOP kunnen klassen ook functies van andere klassen gebruiken, waardoor je niet steeds dezelfde code hoeft te schrijven. Dit alles maakt de code schoner, gemakkelijker te repareren en beter georganiseerd.
Duidelijke code van OOP helpt teams beter samen te werken. Het is voor iedereen makkelijker om te begrijpen wat de code doet, wat betekent dat je minder tijd kwijt bent met uitleggen en meer tijd overhoudt om het werk te doen. Er worden ook minder fouten gemaakt, waardoor het project beter op schema blijft. En als code netjes en overzichtelijk is, kunnen nieuwe teamleden het snel inhalen.
OOP implementeren in PHP
In OOP voor PHP organiseer je code met klassen en objecten, zoals blauwdrukken en huizen. Je maakt klassen voor alles (zoals gebruikers of boeken), inclusief hun properties en acties. Vervolgens gebruik je overerving om nieuwe klassen te bouwen op basis van bestaande klassen, waardoor je tijd bespaart door code niet te herhalen. En omdat inkapseling sommige delen van een klasse privé houdt, is je code veiliger.
De volgende paragrafen laten je zien hoe je de OOP principes effectief kunt gebruiken in je PHP programmering. We maken een content management systeem (CMS) voor het beheren van artikelen.
1. Definieer een klasse met properties en methoden
Begin met een klasse Article die properties bevat voor titel, inhoud en status – samen met methoden om deze properties in te stellen en weer te geven.
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. Maak objecten en implementeer method chaining
Maak een artikelobject en gebruik method chaining om de properties ervan in te stellen:
$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. Versterk encapsulation en inheritance
Verbeter de encapsulation door getter- en settermethoden te gebruiken en maak een klasse FeaturedArticle die erft van 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. Interfaces en polymorfisme
Definieer een interface voor publiceerbare content en implementeer deze in de klasse Article om polymorfisme toe te voegen:
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. Gebruik traits voor gedeeld gedrag
PHP staat je toe om traits te gebruiken om functies toe te voegen aan klassen zonder dat je hoeft te erven van een andere klasse. Gebruik de onderstaande code om een property te introduceren voor het loggen van activiteiten binnen het 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.");
}
}OOP in WordPress ontwikkeling
OOP principes verbeteren de ontwikkeling van WordPress aanzienlijk, vooral bij het maken van thema’s, plugins en widgets. Met behulp van OOP kun je schonere, schaalbare en beter onderhoudbare code schrijven voor je WordPress sites.
In dit gedeelte bespreken we hoe je OOP kunt toepassen bij het ontwikkelen van WordPress. We geven voorbeelden die je kunt kopiëren en plakken in een WordPress deployment om te testen.
OOP in WordPress thema’s: Custom posttype registratie
Om het gebruik van OOP in WordPress thema’s te demonstreren, maak je een klasse die de registratie van een custom berichttype afhandelt.
Plaats de volgende code in het bestand functions.php van je thema. Je kunt je thema’s vinden in de map 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);Deze code registreert dynamisch een custom berichttype book waarvan de details worden doorgegeven met behulp van de bookArgs array. Je kunt het nieuw aangemaakte aangepaste posttype zien in de zijbalk van de WordPress admin met het label Books.
Dit voorbeeld illustreert hoe OOP de functionaliteit voor het registreren van custom berichttypes kan inkapselen, waardoor het herbruikbaar wordt voor verschillende typen berichten.
OOP in WordPress plugins: Shortcode handler
Voor een plugin voorbeeld ontwikkel je een klasse die een shortcode afhandelt voor het weergeven van een speciaal bericht. Je kunt deze functie testen door de onderstaande shortcode toe te voegen aan een bericht of 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();Sla deze op als my-oop-shortcode-handler.php in de wp-content/plugins map. Activeer tot slot de plugin.
Gebruik vervolgens de shortcodes [oop_message] en [oop_message message="Custom Message Here"] in de editor van pagina’s of berichten voordat je ze publiceert of bijwerkt, zoals hieronder getoond:
Na het publiceren of bijwerken van de pagina/bericht zie je het bericht dat de shortcodes hebben weergegeven.
OOP in WordPress widgets: widget voor dynamische inhoud
OOP is ook nuttig voor widgets door hun functionaliteit in klassen in te kapselen. WordPress core gebruikt zelf OOP voor widgets. Hier maak je een aangepaste widget waarmee gebruikers dynamische inhoud kunnen weergeven met een titel en een tekstgebied.
Voeg de volgende code toe aan het bestand functions.php van je thema of in een plugin. Het definieert een aangepaste widget die het bericht “Hellow World From My Custom Widget!” weergeeft
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');Als je het actieve thema bewerkt met de link Edit onder Apperancein het beheergebied, kun je een nieuwe aangepaste widget toevoegen waar dat nodig is.
WordPress klassen gebruiken
WordPress biedt verschillende klassen die je kunt gebruiken voor interactie met de kernfunctionaliteit van het CMS. Twee van deze klassen zijn WP_User en WP_Post, die respectievelijk gebruikers en berichten vertegenwoordigen.
Als je het WordPress plugin voorbeeld van hierboven uitbreidt, kun je deze klassen gebruiken om een shortcode te maken die informatie weergeeft over de auteur van een bericht en details over het bericht zelf.
Sla dit op als my-oop-shortcode-handler-extended.php in de wp-content/plugins map. Activeer tot slot de 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 deze uitgebreide versie heb je een shortcode gemaakt: [post_author_details post_id="1"].
Wanneer het wordt toegevoegd aan een bericht of pagina, geeft het details weer over de auteur van het bericht (met behulp van de klasse WP_User) en het bericht zelf (met behulp van de klasse WP_Post).
OOP en de WordPress REST API
De WordPress REST API is een moderne toevoeging aan WordPress waarmee je op een meer programmeerbare manier kunt communiceren met de gegevens van de site. Er wordt veel gebruik gemaakt van OOP, waarbij klassen worden gebruikt om de eindpunten, antwoorden en de afhandeling van verzoeken te definiëren. Dit is een duidelijke stap van de traditionele procedurele wortels naar het omarmen van OOP.
In schril contrast met de OOP principes is een groot deel van de kern van WordPress, vooral de eerdere onderdelen zoals de thema’s en plugins API, geschreven in een procedurele programmeerstijl.
Terwijl een procedurele aanpak bijvoorbeeld direct globale variabelen manipuleert en vertrouwt op een opeenvolging van functies voor taken, kapselt OOP in de REST API de logica in klassen in. Daarom handelen specifieke methoden binnen deze klassen taken af zoals het ophalen, creëren, bijwerken of verwijderen van berichten.
Dit scheidt zorgen duidelijk en maakt de codebase eenvoudiger uit te breiden en te debuggen.
Door middel van klassen die eindpunten definiëren en verzoeken afhandelen, zoals het ophalen van berichten met een GET /wp-json/wp/v2/posts verzoek, biedt de REST API een gestructureerde, schaalbare manier voor interactie met WordPress gegevens, waarbij JSON geformatteerde antwoorden worden teruggestuurd.
Kinsta gebruiken voor PHP en WordPress hosting
De hostingoplossingen van Kinsta helpen bij het optimaliseren van PHP applicaties en het beheren van WordPress hosting, waarbij wordt voorzien in traditionele PHP opstellingen en WordPress specifieke behoeften. Met een robuuste infrastructuur die is gebouwd op geavanceerde technologieën zoals Google Cloud, biedt Kinsta ongeëvenaarde prestaties en schaalbaarheid voor OOP gebaseerde PHP applicaties.
Voor WordPress sites biedt de gespecialiseerde WordPress Hosting dienst van Kinsta features zoals automatische updates, beveiligingsmonitoring en deskundige ondersteuning. Het garandeert probleemloos beheer en superieure prestaties, waardoor het ideaal is voor zowel developers als bedrijven.
Samenvatting
Zoals je in dit artikel hebt kunnen lezen, biedt OOP ongeëvenaarde flexibiliteit, schaalbaarheid en onderhoudbaarheid bij de ontwikkeling van PHP en WordPress.
Als toonaangevende provider van managed WordPress hosting erkent Kinsta deze behoefte en biedt het oplossingen op maat om developers zoals jij te ondersteunen bij je OOP PHP inspanningen. Daarom zijn onze Applicatie en WordPress Hosting oplossingen ontworpen om je te helpen bij het bouwen van krachtige, schaalbare, OOP gebaseerde WordPress projecten.
Probeer Kinsta vandaag nog om te zien hoe we je kunnen helpen bij het bouwen van topklasse WordPress sites!
Heb je de voordelen van OOP ervaren in je projecten? Of ben je benieuwd hoe het je ontwikkelproces kan transformeren? Deel het hieronder in de reacties.
Kinsta
Content & Marketing Editor at Kinsta, WordPress Web Developer, and Content Writer. Outside of all things WordPress, I enjoy the beach, golf, and movies. I also have tall people problems ;).
