Accentsconagua

Objektorientiertes automatisches Laden in WordPress, Teil 3

Code
Share

Im letzten Tutorial haben wir den ursprünglichen Zustand unseres Autoloaders überprüft und anschließend einen objektorientierten Analyse- und Designprozess durchlaufen. Damit wollen wir alles, was wir in dieser Serie und in der Einführungsserie behandelt haben, zusammenführen. 

Zweitens ist dies der Zweck dieses Tutorials, damit wir den Rest der Zeit damit verbringen können, durch unsere Klasse zu gehen, zu sehen, wie die einzelnen Teile zusammenpassen, in unser Plugin implementieren und dann sehen, wie die objektorientierte Programmierung und das Programm angewendet werden Das Prinzip der Einzelverantwortung kann zu einer fokussierten, wartungsfähigeren Lösung führen.

Bevor wir loslegen

An dieser Stelle gehe ich davon aus, dass Sie diese Serie mitverfolgt haben. Wenn nicht, dann lesen Sie bitte Teil 1 und Teil 2. Es wird davon ausgegangen, dass Sie bisher mitverfolgt haben.

Wenn Sie ein Anfänger sind, empfehle ich Ihnen, auch die erste Serie in ihrer Gesamtheit zu lesen. Wenn Sie erst einmal gefangen sind, sollten Sie in einer guten Position sein, um die Serie abzuschließen, da wir den Rest des in diesem Tutorial behandelten Quellcodes abschließen.

Was wir bisher gemacht haben

Um eine kurze Zusammenfassung zu geben und um sicherzustellen, dass wir uns alle auf derselben Seite befinden, haben wir in dieser Serie die folgenden Themen behandelt:

  • hat die Definition einer Klassenschnittstelle überprüft
  • gesehen, wie eine Klasse eine Schnittstelle implementiert
  • das Prinzip der Einzelverantwortung überprüft
  • analysierte unseren bestehenden Autoloader
  • eine Roadmap für unsere objektorientierte Version des Autoloaders erstellt
  • und entwarf eine Basisimplementierung für eine objektorientierte Version des Autoloaders

An diesem Punkt können wir unseren vorhandenen Autoloader durch den objektorientierten Code austauschen. Beachten Sie jedoch, dass dies nicht nur eine einfache Angelegenheit ist, wenn Sie Dateien ändern. 

Was wir machen müssen

Stattdessen müssen wir die Dateien erstellen, sicherstellen, dass sie den WordPress-Codierstandards folgen, sie implementieren, ihre Implementierung testen, um sicherzustellen, dass das Plugin weiterhin funktioniert, und den vorhandenen Autoloader entfernen.

Das hört sich nach viel Arbeit an, aber wenn unsere Analyse und das Design aus dem vorherigen Tutorial korrekt durchgeführt wurden und sich als richtig erweisen, dann sollten wir kaum Probleme haben, die oben aufgeführten Aufgaben zu lösen.

Ihre Entwicklungsumgebung

Bevor wir in die Implementierung einsteigen, möchte ich einen kurzen Überblick über die Entwicklungsumgebung geben, die Sie auf Ihrem System haben sollten. Technisch gesehen sollten Sie dies bereits gemäß den Anweisungen in den vorherigen Tutorials ausführen, aber ich möchte so vollständig wie möglich sein.

  • eine lokale Entwicklungsumgebung, die für Ihr Betriebssystem geeignet ist
  • ein Verzeichnis, in dem WordPress 4.6.1 gehostet wird
  • ein Texteditor oder eine IDE
  • Kenntnis der WordPress Plugin API

Nachdem dies gesagt ist, lasst uns anfangen.

Objektorientierte Implementierung

In diesem Abschnitt werden wir den gesamten Code, den wir im vorigen Lernprogramm durchgesehen haben, erneut betrachten. Wir werden uns jedoch jede einzelne Datei zusammen mit der vollständigen Dokumentation ansehen.

Außerdem werden wir es in unser Projekt aufnehmen, sodass wir diesen Code am Ende des Tutorials anstelle des einzelnen, prozedural-basierten Codes verwenden können, den wir zuvor verwendet haben.

Beachten Sie, dass jede der folgenden Dateien als aufgeführt bezeichnet und in der Datei enthalten sein sollte inc Verzeichnis. Darüber hinaus steht das alles über die blaue Schaltfläche in der Seitenleiste dieses Beitrags zum Download bereit.

class-autoloader.php

namespace_validator = neuer NamespaceValidator (); $ this-> file_registry = new FileRegistry ();  / ** * Versucht den angegebenen Dateinamen zu laden. * * @param string $ filename Der Pfad zu der Datei, die Sie laden möchten. * / public function load ($ dateiname) if ($ this-> namespace_validator-> is_valid ($ filename)) $ this-> file_registry-> load ($ filename);

class-namespace-validator.php

class-file-investigator.php
get_file_name ($ file_parts, $ current, $ i); if (count ($ file_parts) - 1! == $ i) $ filepath = trailingslashit ($ filepath);  return $ filepath;  / ** * Ruft die Position eines Teils des Dateinamens auf der Festplatte ab, basierend auf dem aktuellen Index des * -Arrays, das untersucht wird. * * @access private * @param array $ file_parts Das Array aller Teile des Dateinamens. * @param string $ current Der aktuelle Teil der zu prüfenden Datei. * @param int $ i Der aktuelle Index des Arrays von $ file_parts, das untersucht werden soll. * @return string Der Name der Datei auf der Festplatte. * / private Funktion get_file_name ($ file_parts, $ current, $ i) $ filename = "; if (count ($ file_parts) - 1 === $ i) if ($ this-> is_interface ($ file_parts))  $ filename = $ this-> get_interface_name ($ file_parts); else $ filename = $ this-> get_class_name ($ current); else $ Dateiname = $ this-> get_namespace_name ($ current); gibt $ filename zurück ; / ** * Bestimmt, ob es sich bei der angegebenen Datei um eine Schnittstelle handelt. * * @Access private * @param array $ file_parts Die zu prüfenden Teile des Dateipfads. * @Return bool True, wenn die Schnittstelle im Dateinamen enthalten ist, andernfalls , false. * / private Funktion is_interface ($ file_parts) return strpos (strtolower ($ file_parts [count ($ file_parts) - 1]), 'interface'); / ** * Ruft den Dateinamen des Interfaces ab angegebene Teile der Datei * an den Autoloader übergeben. * * @access private * @param array $ file_parts Das zu untersuchende Teil der Datei. * @return string Der Dateiname der Schnittstelle. * / private fu Funktion get_interface_name ($ file_parts) $ interface_name = explode ('_', $ file_parts [Anzahl ($ file_parts) - 1]); $ interface_name = $ interface_name [0]; Rückgabe "interface- $ interface_name.php";  / ** * Erzeugt den Namen des Klassendateinamens auf der Festplatte. * * @access private * @param string $ current Der aktuelle Teil des zu prüfenden Dateinamens. * @return string Der Dateiname der Klasse auf der Festplatte. * / private Funktion get_class_name ($ current) return "class- $ current.php";  / ** * Erstellt eine Zuordnung des Namespaces zur Verzeichnisstruktur. * * @access private * @param string $ current Der aktuelle Teil der zu untersuchenden Datei. * @return string Der Pfad der Namensraumzuordnung zur Verzeichnisstruktur. * / private Funktion get_namespace_name ($ current) return '/'. $ current;  
class-file-registry.php
investigator = new FileInvestigator ();  / ** * Verwendet den Dateiermittler, um den Speicherort der Datei auf der Festplatte abzurufen. Wenn gefunden, dann * wird es in das Projekt aufgenommen; Andernfalls wird eine WordPress-Fehlermeldung ausgegeben. * * @param string $ filepath Der Pfad zu der Datei auf der Festplatte, die in das Plugin aufgenommen werden soll. * / public function load ($ filepath) $ filepath = $ this-> investigator-> get_filetype ($ filepath); $ filepath = rtrim (plugin_dir_path (dirname (__FILE__)), '/'). $ filepath; if (file_exists ($ filepath)) include_once ($ filepath);  else wp_die (esc_html ('Die angegebene Datei ist nicht vorhanden.'));  
Dateien einschließen, Autoloader starten
Nachdem wir unsere Dateien erstellt haben, müssen wir noch zwei kleine Änderungen vornehmen:
     
  1. Wir müssen alle Klassen in das inc-Verzeichnis aufnehmen.
    2.  
  2. Wir müssen den alten Autoloader-Code loswerden.
    3.  
  3. Und wir müssen unseren neuen Autoloader mit dem verwenden spl_autoload_register Funktion.
    4.  
Letztendlich sollte die endgültige Version von autoload.php so aussehen:
Und es wird genau das erreichen, was wir oben beschrieben haben.
Aber warte, ich bekomme einen Fehler!
An diesem Punkt haben Sie viel Arbeit geleistet. Sie haben Ihren gesamten Autoloader für die objektorientierte Programmierung überarbeitet. Sie haben Ihre Klassen und Funktionen dokumentiert. Sie haben neue Dateien erstellt, Code aus alten Dateien entfernt und Sie können sicherstellen, dass alles wie erwartet funktioniert.
Daher starten Sie wie jeder Entwickler das Browserfenster, um die Seite zu aktualisieren, und es wird eine Fehlermeldung angezeigt:
Zum Glück ist dies eine einfache Lösung. Das Problem ist, dass wir versuchen, unsere Meta-Box zu früh hinzuzufügen. Um dies zu beheben, aktualisieren wir die drin Methode in unserem Meta_Box Klasse, um dies aufzunehmen:
Und dann werden wir eine Funktion einführen, die an die Arbeit gebunden ist, die wir gerade gemacht haben:
Anzeige, 'Rendern'), 'Post', 'Seite', 'Hoch'); 
An diesem Punkt sollten Sie den neuen Code ohne Probleme, ohne Warnungen, ohne Hinweise und ohne Fehler ausführen können.
Fazit
All das durchzusehen, schien viel zu sein - und das war es auch! Aber das Schöne ist, dass es in drei Tutorials eine Menge Boden abdeckte, und es baute auf der Arbeit einer vorherigen Serie auf. Dabei wurden viele neue Themen behandelt und neue Techniken erlernt.
Beachten Sie, dass ich regelmäßig für Envato Tuts + schreibe. Alle vorherigen Tutorials finden Sie auf meiner Profilseite. Außerdem bespreche ich häufig Softwareentwicklung im Kontext von WordPress in meinem Blog und auf Twitter. Sie können mich also gerne an jedem Ort verfolgen.
Studieren Sie den Code, den wir in dieser Serie behandelt haben (und vielleicht auch den davor), und sehen Sie, ob Sie einige dieser Techniken nicht in Ihre vorhandene oder zukünftige Arbeit einsetzen können.
Ressourcen
     
  •  Verwenden von Namespaces und automatisches Laden in WordPress-Plugins
    •  
  • Objektorientiertes automatisches Laden in WordPress, Teil 1
    •  
  • Objektorientiertes automatisches Laden in WordPress, Teil 2
    •  
  • Namensräume
    •  
  • Autoloading
    •  
  • Schnittstellen
    •  
  • Die WordPress Plugin-API
    •  
  • Grundsatz der Einzelverantwortung
    •  





	
	
			
	   
	







Code
×