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!