Objektorientierte Entwicklung mit WordPress

objektorientiertes Code ist überall und WordPress ist keine Ausnahme.

Der Kern von WordPress basiert auf einer Reihe von Objekten/Klassen, mit denen alles von der Manipulation der Datenbank bis zum Erscheinungsbild Ihrer Website gesteuert wird.

In diesem Tutorial werden wir uns mit dem objektorientierten Design befassen und wie Sie diese in praktischen Anwendungen verwenden können, wenn Sie sich für WordPress entwickeln, einschließlich:

• genau verstehen, was objektorientiertes Design ist.
• diskutieren, warum wir objektorientiertes Design verwenden sollten.
• Untersuchung eines Beispiels für reale Welt, um zu zeigen, wie es funktionieren kann.

Hinweis 1: Beachten Sie auch, dass dieses Tutorial in erster Linie WordPress -zentrische Konzepte umzusehen. Wenn Sie also völlig neu für objektorientiertes Design sind, sollten Sie über den PHP -Referenzhandbuch wahrscheinlich einen kurzen Überblick über OO erhalten.

Anmerkung 2: Wenn Sie alles sofort herunterladen möchten, können Sie die Quelle aus meinem Github -Repository herunterladen und dem Tutorial folgen.

Lassen Sie uns direkt hineinspringen!

Key Takeaways

• Objektorientiertes Design (OOD) in WordPress -Gruppen verwandte Funktionen und Informationen in Klassen, die die Organisation und die Wartung der Code verbessern.
• ood bietet Vorteile wie eine bessere Organisation durch Kapselung, Skalierbarkeit durch Vererbung und Modularität für eine leichtere Wiederverwendung und Verwaltung von Code.
• Das Tutorial bietet ein praktisches Beispiel für das Erstellen eines benutzerdefinierten Ereignissequariums in WordPress, wobei die Implementierung von OOD -Prinzipien demonstriert wird.
• Schlüsselschritte im Beispiel enthalten das Einrichten einer Verzeichnisstruktur, das Erstellen von Klassendateien und das Implementieren von Funktionen zum Hinzufügen und Anzeigen benutzerdefinierter Inhaltstypen und Meta -Boxen.
• Der Leitfaden betont die Vorteile von OOD gegenüber prozeduraler Programmierung, Hervorhebung der Organisation, Skalierbarkeit und Modularität.
• Das Tutorial endet mit einem Aufruf zum Handeln zum Herunterladen des Quellcode von GitHub und ermutigt die Leser, die nachgewiesenen OOD -Konzepte in ihren WordPress -Entwicklungsprojekten anzuwenden.

Was ist überhaupt objektorientiertes Design?

Objektorientierungsdesign (OO -Design) ist eine andere Methodik zum Lösen von Problemen, getrennt vom traditionellen prozeduralen Ansatz.

Mit objektorientiertem Design erstellen Sie eine Struktur (Klasse), die alle Ihre damit verbundenen Funktionen (Methoden) und Informationen (Eigenschaften) zusammenfassen, um ein Problem zu lösen.

Dies unterscheidet sich von der prozeduralen Entwicklung, in der Sie Funktionen und Variablen erstellen, um Probleme zu lösen. Diese Elemente können jedoch über mehrere Dateien getrennt, neu deklariert und oft locker verwandt.

Kurz gesagt, objektorientiertes Design geht es darum, die damit verbundene Funktionalität an einen einzelnen Ort zusammenzubringen, damit es von einem einzelnen Ort aufrechterhalten, erweitert und verwendet werden kann.

Warum Objektorientierung eine gute Idee ist?

Da der Verfahrenscode gut funktioniert hat, fragen Sie sich vielleicht, worum es geht, um sich in einem objektorientierten Ansatz zu entwickeln?

Obwohl es mit prozeduralem Design nichts „Falsches“ gibt, hat die Entwicklung in einem objektorientierteren Stil mehrere Vorteile.

Organisation

Ihr Code ist im Allgemeinen besser organisiert, wenn Sie einen objektorientierten Ansatz verwenden. Das Erstellen von Klassen bedeutet, dass die Funktionalität für die Lösung Ihres Problems in einer Datei liegt (im Gegensatz zu prozeduralen Entwicklung, in der Sie überall Funktionen und Variablen verbreiten können).

Wenn Sie Ihren gesamten Code an einem Ort haben, können Sie die Dinge organisieren und andere Entwickler unterstützt, die möglicherweise mitkommen und verstehen müssen, wie Ihr System funktioniert.

Es gibt nichts Schlimmeres, als ein Projekt abzuholen und zu jagen, um die Funktionen und Variablen zu finden, die zum Erstellen verschiedener Elemente der Website verwendet werden (die aus unbekannten Gründen aus Gründen aus Gründen aus Gründen verteilt sind).

Skalierbarkeit

Wenn Sie Probleme mit einem objektorientierten Ansatz lösen, erstellen Sie Klassen.

Diese Klassen können erweitert oder skaliert werden, indem sie mithilfe der Vererbung erweitert werden. Mit der Vererbung können Sie eine Klasse erstellen, die auf einer anderen Klasse basiert, die Zugriff auf alle Eigenschaften und Methoden zur neuen Klasse ermöglicht.

Sie können eine Klasse erweitern, um zusätzliche Funktionen auszuführen, oder sogar ihre Methoden und Eigenschaften überschreiben, um die Situation zu berücksichtigen.

mit prozeduralem Code, den Sie entweder einen Teil Ihres Codes neu aufstellen oder einen neuen Code vollständig erstellen müssen, um zusätzliche Situationen zu bearbeiten.

Modularität

Der Zweck des objektorientierten Designs besteht darin, die gesamte Funktionalität zu verringern, um eine Situation in eine Klasse zu lösen.

Da sich der gesamte Code zur Lösung eines Problems in einer Klasse befindet und diese Klasse im Allgemeinen in seiner eigenen PHP -Datei eine gesamte Datei einnehmen und an einem anderen Ort verwenden, ist er somit modular in der Natur.

Der Vorteil davon ist, dass Sie sie später wiederverwenden können, wenn Sie Kurse gut genug schreiben und nur leichte Anpassungen durchführen müssen.

Während Sie prozedurale Code kopieren und einfügen können, ist er im Allgemeinen nicht so gut organisiert und Sie müssen möglicherweise mehrere Dateien durchgehen, um sicherzustellen, dass Sie über die erforderliche Funktionen verfügen.

Beispielszenario - Erstellen eines einfachen Ereignis -Showcase

In diesem Szenario möchte unser Kunde einen Standort auf seiner Website, an dem er Veranstaltungen erstellen und verwalten kann. Diese Veranstaltungen werden verwendet, um bevorstehende Trivia -Nächte, Bingo -Wettbewerbe und andere lustige Aktivitäten zu fördern.

Die ersten Schritte sind, die gewünschten Funktionalität zu brechen, damit wir unsere Lösung planen können (hier zu planen, hilft unserem objektorientierten Ansatz in Zukunft). In unserem Szenario können wir die folgenden Aufgaben sehen:

• Erstellen Sie einen benutzerdefinierten Inhaltstyp, um diese „Ereignisse“ zu verwalten.
• Zusätzliche Meta -Boxen hinzufügen, um zusätzliche Informationen zu verarbeiten.
• zusätzliche Meta -Informationen speichern.
• Meta -Informationen für unsere "Ereignisse" anzeigen.

Wir können entweder ein Plugin erstellen oder das untergeordnete Thema bearbeiten, um diese Funktionalität bereitzustellen.

Für dieses Szenario erstellen wir unsere Funktionalität in einer Datei, die wir dann in das untergeordnete Thema aufnehmen können. Ich habe diese Methode ausgewählt, weil wir unsere Themenvorlagen bearbeiten möchten, damit wir unsere zusätzlichen Ereignisinformationen ausgeben können.

Erhalten Sie Ihr Verzeichnis ein und erstellen Sie Ihre Dateien

Weil wir möchten, dass alles leicht verwaltet und modular wird, beginnen wir zunächst die Ordnerstruktur im untergeordneten Thema.

Ein einfacher Weg, um alles zu organisieren, besteht darin, ein in Ihrem Kindesthema einbezogenes Verzeichnis zu erstellen. Dieses Verzeichnis enthält einen anderen Code oder eine andere Funktionalität, die Ihr Thema enthält/implementiert wird (Sie können dies nennen, was Sie wollen. Der Zweck besteht darin, ein einzelnes Verzeichnis im Thema zu haben).

In diesem Verzeichnis sollten wir einen weiteren Ordner erstellen, diesmal Event_ShowCase. In diesem Ordner werden wir alle unsere entsprechenden Dateien für dieses Szenario platzieren. Wir werden auch einen JS- und einen CSS -Ordner brauchen.

organisiert Ihre Funktionalität in Ordner, dass Sie in Zukunft einfacher sehen können, welche Module / Funktionen Ihr Thema implementiert. Zum Beispiel möchten Sie möglicherweise einen weiteren Satz von Funktionen für Ihr Thema implementieren. Sie können einfach einen neuen Ordner hinzufügen, und logischerweise ist alles ordentlich organisiert.

Erstellen wir die Dateien für unser Beispiel und verschieben sie in ihre korrekten Verzeichnisse

• event_showcase_class.php
• event_showcase_admin_styles.css
• event_showcase_admin_scripts.js
• event_showcase_public_styles.css
• event_showcase_public_scripts.js

Sie sollten etwas Ähnliches haben wie unten:

Später müssen Sie das JQuery Time Picker -Skript und -Stil in dieses Verzeichnis herunterladen und platzieren. Mach dir vorerst keine Sorgen.

Laden Sie Ihre Dateien in WordPress

Mit unseren Dateien müssen wir sie jetzt in unser Kinderthema einbeziehen.

Öffnen Sie die Funktionen Ihres Kindes und platzieren Sie den folgenden Code entweder oben oder unten

<span>//Theme functions for child theme
</span>
<span>//load our event showcase class
</span><span>$event_showcase = get_stylesheet_directory() . '/includes/event_showcase/event_showcase_class.php';
</span><span>include($event_showcase);</span>

lädt die Hauptklassendatei, die unsere Funktionalität beschreibt. Innerhalb dieser Klasse werden wir mit Skript und Stil zusammen mit anderen Elementen umgehen.

Erstellen Sie Ihre Klassenriss

Unsere Klassendatei namens event_showcase_class.php enthält den größten Teil der für unser Ereignissystem verwendeten Funktionen. Als solches ist es eine gute Idee, einen grundlegenden Überblick darüber nachzubilden, welche Methoden und Eigenschaften wir benötigen, um diese Arbeit zu machen.

Kopieren Sie den folgenden Code in Ihre Klassendatei.

<span>//Theme functions for child theme
</span>
<span>//load our event showcase class
</span><span>$event_showcase = get_stylesheet_directory() . '/includes/event_showcase/event_showcase_class.php';
</span><span>include($event_showcase);</span>

Lassen Sie uns die Methoden und Eigenschaften durchlaufen, damit wir den Prozessfluss verstehen können:

• Variablen - Wir deklarieren einige Variablen, um die Klasse modularer zu gestalten (damit wir diese Datei kopieren und einige Eigenschaften ändern können, und die Klasse wird die anderen Änderungen umgehen).
• __ construct () - Alle unsere Hooks, Filter und Initialisierungscode werden hier reingehen.
• set_directory_value () - definiert unsere Verzeichniseigenschaft, mit der wir Dateien, die wir in unseren CSS- oder JS -Verzeichnissen aufstellen, leicht aufnehmen können.
• check_flush_rewrite_rules () - verarbeitet das Spülen der hübschen Permalinks, wenn wir unseren Inhaltstyp hinzufügen (wodurch die neuen Elemente funktionieren).
• enqueue_public_scripts_and_styles () - lädt unsere öffentlichen Skripte und Stile.
• enqueue_admin_scripts_and_styles () - lädt die Administratorskripte und Stile.
• add_content_type () - definiert den neuen Inhaltstyp, den wir erstellen.
• add_meta_boxes_for_content_type () - fügt die Meta -Boxen für unseren neuen Inhaltstyp hinzu.
• display_function_for_content_type_meta_box-Erstellt die Back-End-Administratorschnittstelle für den Inhaltstyp, sodass wir zusätzliche Informationen speichern können.
• save_custom_content_type ($ post_id) - Vervollständigt das Speichern des benutzerdefinierten Inhaltstyps (und unsere Meta -Informationen).
• display_additional_meta_data () - Zeigt die gespeicherten Meta -Informationen am vorderen Ende an.

Lassen Sie uns jetzt durchgehen und diese Elemente aktualisieren und den Code

skizzieren

Die Klasseneigenschaften

Wir deklarieren einige Eigenschaften an der Spitze unserer Klasse, auf die über unsere Methoden verwiesen werden. Der Zweck dieser ist, dass sie es einfacher machen, diese Klasse erneut zu belegen und ihre Funktionalität in Zukunft zu ändern.

<span>/*
</span><span> * Event Showcase
</span><span> * Creates an 'event' content type to showcase upcoming functions and information
</span><span> * Uses hooks and filters inside your theme to output relevant information
</span><span> */
</span> 
 <span>class event_showcase{
</span> 	
	<span>//variables
</span>	<span>private $directory = '';
</span>	<span>private $singular_name = 'event';
</span>	<span>private $plural_name = 'events';
</span>	<span>private $content_type_name = 'event_showcase';
</span>	
	<span>//magic function, called on creation
</span>	<span>public function __construct(){}
</span>	<span>//sets the directory (path) so that we can use this for our enqueuing
</span>	<span>public function set_directory_value(){}
</span>	<span>//check if we need to flush rewrite rules
</span>	<span>public function check_flush_rewrite_rules(){}
</span>	<span>//enqueue public scripts and styles
</span>	<span>public function enqueue_public_scripts_and_styles(){}
</span>	<span>//enqueue admin scripts and styles
</span>	<span>public function enqueue_admin_scripts_and_styles(){}
</span>	<span>//adding our new content type
</span>	<span>public function add_content_type(){}
</span>	<span>//adding meta box to save additional meta data for the content type
</span>	<span>public function add_meta_boxes_for_content_type(){}
</span>	<span>//displays the visual output of the meta box in admin (where we will save our meta data)
</span>	<span>public function display_function_for_content_type_meta_box($post){}
</span>	<span>//when saving the custom content type, save additional meta data
</span>	<span>public function save_custom_content_type($post_id){}
</span>	<span>//display additional meta information for the content type
</span>	<span>//@hooked using 'display_additional_meta_data' in theme
</span>	<span>function display_additional_meta_data(){}
</span> <span>}
</span> 
 <span>//create new object 
</span> <span>$event_showcase = new event_showcase;</span>

__ construct ()

Unsere __construct -Funktion ist eine magische Funktion. Diese Funktionen sind spezielle PHP5 -Funktionen, auf die Klassen zugreifen können, um bestimmte Aktionen auszuführen.

alle beginnen mit dem doppelten Unterstrich vor ihrem Namen und können optional in jeder Klassendefinition integriert werden. Das Verständnis aller magischen Funktionen ist für eine weitere Diskussion am besten übrig (hier ist ein weiterer Artikel über magische Funktionen und Konstanten).

Die __construct -Funktion wird aufgerufen, sobald eine Klasse initialisiert ist, so dass die erste Funktion ausgelöst wird. Hier fügen wir alle unsere Haken, Filter und Startlogik hinzu. Aktualisieren Sie die grundlegende Gliederung mit dem folgenden Code.

<span>//variables
</span><span>private $directory = '';	
</span><span>private $singular_name = 'event';
</span><span>private $plural_name = 'events';
</span><span>private $content_type_name = 'event_showcase';</span>

Sie denken vielleicht, dass die Add_Action etwas anders aussieht als das, was Sie zuvor gesehen haben, und Sie sind richtig.

Bei Verwendung von Add_Action und Add_filter -Aufrufen in einer Klasse müssen Sie das zweite Argument in einem Array angeben. Der erste Wert des Arrays ist die $ diese Variable (dh die Klasse selbst) und der zweite der Name der Funktion, die verwendet wird (in Anführungszeichen eingewickelt).

Weitere Informationen anzeigen Sie die Klassenfußnote für die Funktion add_action im WordPress -Codex.

set_directory_value ()

Da wir CSS und JS aufnehmen werden, ist es sinnvoll, die URL der Dateiverzeichnis in eine Variable zu speichern, auf die wir zugreifen können. Unsere Verzeichnisstruktur ist /inklusive /event_showcase, kann jedoch an Ihre Struktur angepasst werden.

<span>//Theme functions for child theme
</span>
<span>//load our event showcase class
</span><span>$event_showcase = get_stylesheet_directory() . '/includes/event_showcase/event_showcase_class.php';
</span><span>include($event_showcase);</span>

check_flush_rewrite_RULES ()

Da wir einen benutzerdefinierten Inhaltstyp hinzufügen, müssen wir hübsche Permalinks verarbeiten. Diese Permalinks sind umschreiben, die Ihre Seiten-URL weniger hässlich aussehen lassen (anstatt http://mywebsite.com.au/?p=123 zu haben, können Sie http://mywebsite.com.au/my-event).

Umschreiben stellt sicher, dass Ihre Inhaltstypen in das hübsche Format umgewandelt werden. Dieses Umschreiben ist jedoch teuer und kann Ihre Website übermäßig verlangsamen. Da das Umschreiben Ihre Website beeinflussen kann, wird sie im Allgemeinen nur zur Aktivierung oder Deaktivierung von Themen/Plugin geändert.

Da Sie Ihre Permalinks möglicherweise nicht manuell aktualisieren möchten, fordert diese Funktion WordPress auf, dies automatisch und nur einmal zu tun (nachdem Ihr neuer Inhaltstyp hinzugefügt wurde).

Diese Funktion prüft, ob die Website über eine Themenoption gespült werden muss. Wenn ein Flush erforderlich ist, wird die Permalinks aktualisiert und dann den Wert der Option auf False festgelegt (damit sie nur einmal, nicht jedes Mal, wenn wir eine Seite laden).

<span>/*
</span><span> * Event Showcase
</span><span> * Creates an 'event' content type to showcase upcoming functions and information
</span><span> * Uses hooks and filters inside your theme to output relevant information
</span><span> */
</span> 
 <span>class event_showcase{
</span> 	
	<span>//variables
</span>	<span>private $directory = '';
</span>	<span>private $singular_name = 'event';
</span>	<span>private $plural_name = 'events';
</span>	<span>private $content_type_name = 'event_showcase';
</span>	
	<span>//magic function, called on creation
</span>	<span>public function __construct(){}
</span>	<span>//sets the directory (path) so that we can use this for our enqueuing
</span>	<span>public function set_directory_value(){}
</span>	<span>//check if we need to flush rewrite rules
</span>	<span>public function check_flush_rewrite_rules(){}
</span>	<span>//enqueue public scripts and styles
</span>	<span>public function enqueue_public_scripts_and_styles(){}
</span>	<span>//enqueue admin scripts and styles
</span>	<span>public function enqueue_admin_scripts_and_styles(){}
</span>	<span>//adding our new content type
</span>	<span>public function add_content_type(){}
</span>	<span>//adding meta box to save additional meta data for the content type
</span>	<span>public function add_meta_boxes_for_content_type(){}
</span>	<span>//displays the visual output of the meta box in admin (where we will save our meta data)
</span>	<span>public function display_function_for_content_type_meta_box($post){}
</span>	<span>//when saving the custom content type, save additional meta data
</span>	<span>public function save_custom_content_type($post_id){}
</span>	<span>//display additional meta information for the content type
</span>	<span>//@hooked using 'display_additional_meta_data' in theme
</span>	<span>function display_additional_meta_data(){}
</span> <span>}
</span> 
 <span>//create new object 
</span> <span>$event_showcase = new event_showcase;</span>

enqueue_public_scripts_and_styles ()

Diese Funktion übernimmt das Enqueuching der Skripte und Stile für die Website im Front-End.

Wir verwenden den Namen des Inhaltstyps in den Enqueue -Aufrufen, damit keine Namenskonflikte mit anderen Plugins vorhanden sein sollten (da es sich in etwas Einzigartigem übersetzt, d. H. Event_showcase_Public_Scripts`).

wir nennen sowohl wp_enqueue_style als auch wp_enqueue_script, um unsere Ressourcen zu laden.

Wir verwenden auch das $ Verzeichnis und $ content_type_name Eigenschaften beim Laden unserer Ressourcen.

<span>//variables
</span><span>private $directory = '';	
</span><span>private $singular_name = 'event';
</span><span>private $plural_name = 'events';
</span><span>private $content_type_name = 'event_showcase';</span>

enqueue_admin_scripts_and_styles ()

Diese Funktion übernimmt das Enqueuching der Skripte und Stile für die Website im Administrator Back-End.

Wir überprüfen, ob wir uns auf einem Bildschirm oder einem neuen Bildschirm für unseren Inhaltstyp befinden, und gehen Sie nur dann fort, wenn wir uns befinden (keine Ressourcen laden, wenn wir nicht auf der rechten Seite sind).

Wir nennen sowohl wp_enqueue_style als auch wp_enqueue_script, um unsere Ressourcen zu laden, im Wesentlichen wie bei unserer öffentlichen Gesichtsfunktion.

Zum Beispiel verwende ich sowohl den Jquery UI DatePicker (Teil der Jquery UI -Bibliothek) als auch die Jquery UI Time Picker (erstellt, um einen ähnlichen Stil wie der Datumspicker zu haben).

Geh und lade die Time Picker Library aus dem obigen Link herunter und füge die relevante CSS- und JS -Datei in dein Verzeichnis ein.

<span>//magic function, called on creation
</span><span>public function __construct(){
</span>	
	<span>$this->set_directory_value(); //set the directory url on creation
</span>	<span>add_action('init', array($this,'add_content_type')); //add content type
</span>	<span>add_action('init', array($this,'check_flush_rewrite_rules')); //flush re-write rules for permalinks (because of content type)
</span>	<span>add_action('add_meta_boxes', array($this,'add_meta_boxes_for_content_type')); //add meta boxes 
</span>	<span>add_action('wp_enqueue_scripts', array($this,'enqueue_public_scripts_and_styles')); //enqueue public facing elements
</span>	<span>add_action('admin_enqueue_scripts', array($this, 'enqueue_admin_scripts_and_styles')); //enqueues admin elements
</span>	<span>add_action('save_post_' . $this->content_type_name, array($this,'save_custom_content_type')); //handles saving of content type meta info
</span>	<span>add_action('display_content_type_meta', array($this,'display_additional_meta_data')); //displays the saved content type meta info	
</span><span>}</span>

add_content_type ()

Wir deklarieren unseren benutzerdefinierten Inhaltstyp in dieser Funktion.

Die Funktion verwendet $ Singular_Name, $ plural_name und $ content_type_nameproperties, um die Registrierung dieses neuen Beitragstyps zu vereinfachen.

Strukturieren der Registrierungsfunktion wie diese bedeutet, dass Sie einen Post -Typ problemlos ändern und registrieren können, indem Sie nur wenige Informationen einnehmen.

Für eine detailliertere Übersicht über die Registrierung benutzerdefinierter Inhaltstypen finden Sie den WordPress -Codex für die Funktion Register_Post_Type

<span>//Theme functions for child theme
</span>
<span>//load our event showcase class
</span><span>$event_showcase = get_stylesheet_directory() . '/includes/event_showcase/event_showcase_class.php';
</span><span>include($event_showcase);</span>

Sobald Sie diesen Schritt hinzugefügt haben, sollten Sie dem Back-End-WordPress-Menü ein neues Element hinzugefügt haben.

add_meta_boxes_for_content_type ()

Wir fügen die Meta -Boxen hinzu, die wir für unseren Inhaltstyp benötigen. Wir rufen die Funktion add_meta_box auf und geben sie mit Funktionen aus. Die Kurzgeschichte ist, dass wir dies verwenden, um ein neues Administratorfeld zu erstellen, um unsere neuen Formularelemente zu halten, die wir speichern möchten.

<span>/*
</span><span> * Event Showcase
</span><span> * Creates an 'event' content type to showcase upcoming functions and information
</span><span> * Uses hooks and filters inside your theme to output relevant information
</span><span> */
</span> 
 <span>class event_showcase{
</span> 	
	<span>//variables
</span>	<span>private $directory = '';
</span>	<span>private $singular_name = 'event';
</span>	<span>private $plural_name = 'events';
</span>	<span>private $content_type_name = 'event_showcase';
</span>	
	<span>//magic function, called on creation
</span>	<span>public function __construct(){}
</span>	<span>//sets the directory (path) so that we can use this for our enqueuing
</span>	<span>public function set_directory_value(){}
</span>	<span>//check if we need to flush rewrite rules
</span>	<span>public function check_flush_rewrite_rules(){}
</span>	<span>//enqueue public scripts and styles
</span>	<span>public function enqueue_public_scripts_and_styles(){}
</span>	<span>//enqueue admin scripts and styles
</span>	<span>public function enqueue_admin_scripts_and_styles(){}
</span>	<span>//adding our new content type
</span>	<span>public function add_content_type(){}
</span>	<span>//adding meta box to save additional meta data for the content type
</span>	<span>public function add_meta_boxes_for_content_type(){}
</span>	<span>//displays the visual output of the meta box in admin (where we will save our meta data)
</span>	<span>public function display_function_for_content_type_meta_box($post){}
</span>	<span>//when saving the custom content type, save additional meta data
</span>	<span>public function save_custom_content_type($post_id){}
</span>	<span>//display additional meta information for the content type
</span>	<span>//@hooked using 'display_additional_meta_data' in theme
</span>	<span>function display_additional_meta_data(){}
</span> <span>}
</span> 
 <span>//create new object 
</span> <span>$event_showcase = new event_showcase;</span>

display_function_for_content_type_meta_box ($ post)

Wir verwenden diese Funktion, um die Back-End-Optionen für die neuen Meta-Informationen für unseren Inhaltstyp auszugeben.

Für unser Beispiel sammeln wir Daten, Zeiten und andere Informationen über das Ereignis, das wir dem Endbenutzer anzeigen werden.

Wir beginnen damit, alle zusätzlichen Post -Meta in Variablen zu sammeln und die Ausgabe des HTML -Formulars anzuzeigen. Einige dieser Felder auslösen die Date Picker -Schnittstelle und andere löst den Zeitpicker aus (bestimmt durch die im Element verwendete Klasse).

Darüber hinaus setzen wir ein Nonce -Feld, damit wir uns auf Speichern stellen können, wenn die Anfrage von dieser Seite stammt.

<span>//variables
</span><span>private $directory = '';	
</span><span>private $singular_name = 'event';
</span><span>private $plural_name = 'events';
</span><span>private $content_type_name = 'event_showcase';</span>

Wenn Sie alle mit diesem Schritt fertig sind, sollten Sie sehen, dass die neue leere Metabox transformiert wurde und jetzt alle unsere neuen Informationen aufnehmen kann.

SARE_CUSTOM_CONTENT_TYPE ($ pOST_ID)

Hier sparen wir unsere zusätzlichen Meta -Daten für unseren benutzerdefinierten Inhaltstyp.

Wir überprüfen zuerst nach dem Nonce, den wir in unserem Meta -Feld hinzugefügt haben, und überprüfen seine Authentizität. Danach überprüfen wir, dass wir keine Autosave durchführen und dass der Benutzer diese Seite tatsächlich bearbeiten kann. Wenn alle diese Schecks bestanden werden, gehen wir vorwärts.

Wir sammeln alle unsere Werte in Variablen und sanitieren sie mit der Funktion "sanitize_text_field". Danach rufen wir die Funktion update_post_meta auf, um unsere Daten zu speichern.

<span>//magic function, called on creation
</span><span>public function __construct(){
</span>	
	<span>$this->set_directory_value(); //set the directory url on creation
</span>	<span>add_action('init', array($this,'add_content_type')); //add content type
</span>	<span>add_action('init', array($this,'check_flush_rewrite_rules')); //flush re-write rules for permalinks (because of content type)
</span>	<span>add_action('add_meta_boxes', array($this,'add_meta_boxes_for_content_type')); //add meta boxes 
</span>	<span>add_action('wp_enqueue_scripts', array($this,'enqueue_public_scripts_and_styles')); //enqueue public facing elements
</span>	<span>add_action('admin_enqueue_scripts', array($this, 'enqueue_admin_scripts_and_styles')); //enqueues admin elements
</span>	<span>add_action('save_post_' . $this->content_type_name, array($this,'save_custom_content_type')); //handles saving of content type meta info
</span>	<span>add_action('display_content_type_meta', array($this,'display_additional_meta_data')); //displays the saved content type meta info	
</span><span>}</span>

display_additional_meta_data ()

Diese Funktion zeigt die gespeicherten Meta -Informationen für einen einzelnen Beitrag unseres neuen Inhaltstyps (Einzelereignis) an.

Wir haben eine neue Aktion namens display_content_type_meta in unserer __construct -Funktion definiert. So sah es aus:

<span>//sets the directory (path) so that we can use this for our enqueuing
</span><span>public function set_directory_value(){
</span>	<span>$this->directory = get_stylesheet_directory_uri() . '/includes/event_showcase';
</span><span>}</span>

Der zweite Wert dieser Aktion wurde als display_additional_meta_data bezeichnet und entspricht dieser Funktion. Dies bedeutet, dass jedes Mal, wenn jemand do_action anruft ('display_content_type_meta'); Es wird diese Funktion aufrufen und die neuen Post -Meta -Informationen angezeigt.

Sie können do_action aufrufen ('display_content_type_meta'); von überall in Ihrem Thema (solange Sie sich in einem einzelnen Beitrag dieses Inhaltstyps befinden) und die Meta -Informationen anzeigen.

Ich verwende ein übergeordnetes Thema von zwanzig dreizehn, damit ich mich in den Content.php des Kindes für mein Display einbezieht.

Diese Funktion erhält den globalen $ post und $ post_type und prüft, ob der aktuelle Element zu sehen ist, von unserem neuen Inhaltstyp.

Danach sammelt die Funktion die Meta -Informationen und zeigt sie an (einige schnelle Überprüfungen auf dem Weg).

<span>//Theme functions for child theme
</span>
<span>//load our event showcase class
</span><span>$event_showcase = get_stylesheet_directory() . '/includes/event_showcase/event_showcase_class.php';
</span><span>include($event_showcase);</span>

Zusätzliche Dateien, CSS und JS

Jetzt, da der Großteil der Funktionalität abgeschlossen wurde

event_showcase_admin_styles.css

<span>/*
</span><span> * Event Showcase
</span><span> * Creates an 'event' content type to showcase upcoming functions and information
</span><span> * Uses hooks and filters inside your theme to output relevant information
</span><span> */
</span> 
 <span>class event_showcase{
</span> 	
	<span>//variables
</span>	<span>private $directory = '';
</span>	<span>private $singular_name = 'event';
</span>	<span>private $plural_name = 'events';
</span>	<span>private $content_type_name = 'event_showcase';
</span>	
	<span>//magic function, called on creation
</span>	<span>public function __construct(){}
</span>	<span>//sets the directory (path) so that we can use this for our enqueuing
</span>	<span>public function set_directory_value(){}
</span>	<span>//check if we need to flush rewrite rules
</span>	<span>public function check_flush_rewrite_rules(){}
</span>	<span>//enqueue public scripts and styles
</span>	<span>public function enqueue_public_scripts_and_styles(){}
</span>	<span>//enqueue admin scripts and styles
</span>	<span>public function enqueue_admin_scripts_and_styles(){}
</span>	<span>//adding our new content type
</span>	<span>public function add_content_type(){}
</span>	<span>//adding meta box to save additional meta data for the content type
</span>	<span>public function add_meta_boxes_for_content_type(){}
</span>	<span>//displays the visual output of the meta box in admin (where we will save our meta data)
</span>	<span>public function display_function_for_content_type_meta_box($post){}
</span>	<span>//when saving the custom content type, save additional meta data
</span>	<span>public function save_custom_content_type($post_id){}
</span>	<span>//display additional meta information for the content type
</span>	<span>//@hooked using 'display_additional_meta_data' in theme
</span>	<span>function display_additional_meta_data(){}
</span> <span>}
</span> 
 <span>//create new object 
</span> <span>$event_showcase = new event_showcase;</span>

event_showcase_public_styles.css

<span>//variables
</span><span>private $directory = '';	
</span><span>private $singular_name = 'event';
</span><span>private $plural_name = 'events';
</span><span>private $content_type_name = 'event_showcase';</span>

event_showcase_admin_scripts.js

<span>//magic function, called on creation
</span><span>public function __construct(){
</span>	
	<span>$this->set_directory_value(); //set the directory url on creation
</span>	<span>add_action('init', array($this,'add_content_type')); //add content type
</span>	<span>add_action('init', array($this,'check_flush_rewrite_rules')); //flush re-write rules for permalinks (because of content type)
</span>	<span>add_action('add_meta_boxes', array($this,'add_meta_boxes_for_content_type')); //add meta boxes 
</span>	<span>add_action('wp_enqueue_scripts', array($this,'enqueue_public_scripts_and_styles')); //enqueue public facing elements
</span>	<span>add_action('admin_enqueue_scripts', array($this, 'enqueue_admin_scripts_and_styles')); //enqueues admin elements
</span>	<span>add_action('save_post_' . $this->content_type_name, array($this,'save_custom_content_type')); //handles saving of content type meta info
</span>	<span>add_action('display_content_type_meta', array($this,'display_additional_meta_data')); //displays the saved content type meta info	
</span><span>}</span>

Abgeschlossene Funktionalität in Aktion!

Wenn alles zusammengesetzt ist, sollten Sie in der Lage sein, ein neues „Ereignis“ mit zusätzlichen Meta -Daten zu erstellen. Wenn Sie Ihr Ereignis anzeigen, sollten Sie in meinem Beispiel unten etwas sehen

Sie können die zusätzlichen Untertitel, Daten, Zeiten und Ticketdaten sehen.

Erweiterung eines grundlegenden Post -Typs wie diesem und dem Hinzufügen zusätzlicher Elemente hilft dabei, eine viel interaktivere und einfachere Website zu verwalten. Der Benutzer muss nicht mehr alle Informationen über den Inhaltsbereich hinzufügen, der chaotisch, schwierig und inkonsistent sein kann. Sie haben jetzt einfach eine einfache Verwaltung der Schnittstelle.

wohin von hier?

Jetzt, da Sie ein praktisches Beispiel für objektorientiertes Design gesehen haben und wie einfach es sein kann, Ihre Entwicklung zu verbessern, können Sie diese Fähigkeiten anwenden und bessere Themen und Plugins erstellen.

Möglicherweise möchten Sie die Quelle dieses Beispiels von meiner Github -Seite herunterladen und dann an das kommende Projekt geeignet oder erweitern, um zusätzliche Funktionen bereitzustellen.

Hoffentlich hilft Ihnen dieser Artikel bei der Planung Ihrer Entwicklung und zu sehen, wie eine objektorientierte Methodik sowohl Zeit als auch Aufwand sparen kann.

häufig gestellte Fragen zur objektorientierten Entwicklung mit WordPress

Was ist objektorientierte Programmierung (OOP) in WordPress? Diese Objekte werden verwendet, um miteinander zu interagieren, um Anwendungen und Software zu entwerfen. OOP in WordPress ist von Vorteil, da es eine klare modulare Struktur für Programme bietet, die es für die Definition abstrakter DataTypen für die Implementierungsdetails gut macht und das Gerät eine klar definierte Schnittstelle hat.

Wie unterscheidet sich die objektorientierte Programmierung von der prozeduralen Programmierung in WordPress? Andererseits organisiert objektorientierte Programmierungen ein Programm um seine Daten (Objekte) und eine Reihe gut definierter Schnittstellen zu diesen Daten. Dieser Ansatz erleichtert die Verwaltung und Steuerung komplexer Anwendungen, indem sie in kleinere, wiederverwendbare Teile zerlegt werden. Leistung durch Speichern von Daten aus der Datenbank im Speicher, um unnötige Abfragen zu verhindern. Dies kann WordPress erheblich beschleunigen, da die Last in der Datenbank reduziert wird.

Wie kann ich OBJ in einem Feld in WordPress entfernen? Verschiedene Methoden wie Deaktivieren des Objekt -Cache, mithilfe eines Plugins oder das manuelle Entfernen aus dem Code. Es ist jedoch wichtig zu beachten, dass dies sorgfältig durchgeführt werden sollte, um zu vermeiden, dass Sie Ihre Site brechen. In Ihrem WordPress -Thema müssen Sie Klassen und Methoden in Ihrer Datei für Funktionen.Php oder in einzelnen Vorlagendateien definieren. Diese Klassen und Methoden können dann zum Erstellen von Objekten verwendet werden, die miteinander interagieren können, um Aufgaben auszuführen. Die Programmierung in WordPress bietet mehrere Vorteile. Dies macht den Code kompakter, einfacher zu verstehen und leichter zu warten. Es ermöglicht es auch, komplexere Funktionen mit weniger Code zu erstellen. Darüber hinaus ermöglicht es eine bessere Datenanalyse, eine genauere Codierung und eine schnellere Entwicklung. Im Post -Titel in WordPress ist normalerweise ein Ergebnis eines Konflikts mit einem Plugin oder Thema. Es ist kein Standardbestandteil von WordPress, und es kann entfernt werden, indem der Konflikt identifiziert und gelöst wird.

Wie kann ich objektorientierte Programmierung für WordPress lernen? Objektorientierte Programmierung für WordPress. Dies beinhaltet Online -Tutorials, Kurse und Bücher. Sie können auch lernen, indem Sie den WordPress-Kerncode untersuchen, wie er unter Verwendung von OOP-Prinzipien geschrieben wird. WordPress -Entwicklung, es wird sehr empfohlen. Die Verwendung von OOP -Prinzipien kann dazu beitragen, Ihren Code lesbar, wiederverwendbarer und leichter zu warten. Es kann Ihnen auch helfen, den WordPress -Kerncode besser zu verstehen.

Kann ich objektorientierte Programmierung mit WordPress-Plugins verwenden? Tatsächlich werden viele WordPress -Plugins mit OOP -Prinzipien geschrieben. Dies ermöglicht komplexere Funktionen und kann den Plugin -Code erleichtern, das Verwalten und Verwalten zu erleichtern.

Das obige ist der detaillierte Inhalt vonObjektorientierte Entwicklung mit WordPress. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!