Vom Nullpunkt aus: Vorbereitungen und Aufbau der Umgebung
Bevor Sie mit der Erstellung des ersten Plugins beginnen, müssen Sie sich gründlich vorbereiten. Dazu gehört das Verständnis der grundlegenden Struktur von WordPress-Plugins, die Einrichtung einer sicheren lokalen Entwicklungsumgebung sowie das Begreifen der Kernphilosophie der Plugin-Entwicklung.
Ein typisches WordPress-Plugin ist ein Programmteil, das sich in der Datei-Struktur von WordPress befindet. /wp-content/plugins/ Es handelt sich um eine eigenständige Verzeichnisstruktur, in der sich eine PHP-Hauptdatei befindet, die über einen spezifischen Dateihaupteintrag verfügt. Diese Hauptdatei enthält nicht nur Metadaten des Plugins, sondern dient auch als Eingangspunkt für die gesamten Funktionen des Plugins. Es gibt zwei Möglichkeiten, das Plugin zu starten: Entweder durch die Verwendung einer Kombination von prozeduralen Funktionen oder durch die Anwendung einer objektorientierten Klassenstruktur. Letztere wird aufgrund ihrer besseren Abgeschottung und Kodierorganisation in der modernen Plugin-Entwicklung bevorzugt.
Eine lokale Entwicklungsumgebung ist für eine effiziente Entwicklung von entscheidender Bedeutung. Es wird empfohlen, Tools wie XAMPP, Local by Flywheel oder Docker zu verwenden, um eine Umgebung zu erstellen, die Apache/Nginx, MySQL und PHP integriert. Dadurch können Sie Tests und Fehlersuche durchführen, ohne die Funktionen Ihrer Online-Webseiten zu beeinträchtigen.
Empfohlene Lektüre Von Grund auf: Eine vollständige Anleitung zur Entwicklung von WordPress-Plugins und ein Austausch über Best Practices。
Erstellung eines Plugin-Skeletts: Struktur und Kerndateien
In diesem Abschnitt wird ausführlich beschrieben, wie man von Grund auf ein grundlegendes Plugin-Skelett erstellt, das den WordPress-Standards entspricht. Ein gutes Plugin-Skelett bildet die Basis für eine stabile, sichere und wartungsfreundliche Implementierung eines Plugins.
Erstellen Sie die erforderlichen Haupt-Plugin-Dateien.
Das „Leben“ eines Plugins beginnt mit einer Hauptdatei. Der Name dieser Datei entspricht in der Regel dem Namen Ihres Plugins-Ordners. Zum Beispiel: Wenn Ihr Plugins-Ordner den Namen „my-plugin“ trägt, dann heißt die Hauptdatei Ihres Plugins auch „my-plugin“. my-custom-pluginDann kann die Hauptdatei „main_file.txt“ genannt werden. my-custom-plugin.phpAm Anfang dieses Files müssen Sie einen Kommentarblock verwenden, der einem bestimmten Format entspricht, um die Informationen zum Plugin anzugeben. Dies ist entscheidend dafür, dass WordPress das Plugin erkennt und es in der Liste der Backend-Verwaltungsfunktionen anzeigt.
Hier ist ein Beispiel für die einfachste mögliche Plugin-Header-Datei:
<?php
/**
* Plugin Name: 我的自定义功能模块
* Plugin URI: https://example.com/my-custom-plugin
* Description: 这是一个用于演示如何从零开始开发WordPress插件的示例模块。
* Version: 1.0.0
* Author: 你的名字
* Author URI: https://example.com
* License: GPL v2 or later
* Text Domain: my-custom-plugin
* Domain Path: /languages
*/In diesem Kommentar ist der “Plugin Name” erforderlich; die anderen Felder sind optional, aber es wird empfohlen, sie auszufüllen. “Text Domain” und “Domain Path” dienen der Internationalisierung (i18n) des Plugins, um die späterige Übersetzung in mehrere Sprachen zu ermöglichen.
Dateien und Verzeichnisse für die Organisation von Plugins
Mit der Zunahme der Funktionen der Plugins ist es nicht ratsam, den gesamten Code in einer einzigen Hauptdatei zu speichern. Eine gut strukturierte Plugin-Architektur umfasst in der Regel mehrere Unterverzeichnisse und Dateien. Eine häufig verwendete Struktur sieht wie folgt aus:
Empfohlene Lektüre Kompletter Leitfaden für die Entwicklung von WordPress-Plugins: Ein praktischer Tutorial von Grundlagen bis zur Veröffentlichung im Live-Betrieb。
my-custom-plugin/
├── my-custom-plugin.php # 主插件文件（入口）
├── includes/ # 核心功能类文件目录
│ ├── class-core.php # 核心逻辑类
│ └── class-admin.php # 后台管理逻辑类
├── admin/ # 后台相关文件
│ ├── css/ # 后台样式表
│ ├── js/ # 后台JavaScript
│ └── partials/ # 后台模板片段
├── public/ # 前端相关文件
│ ├── css/
│ ├── js/
│ └── partials/
├── assets/ # 公共资源（如图标、图片）
├── languages/ # 国际化语言包（.po, .mo文件）
└── uninstall.php # 插件卸载清理脚本„In“ my-custom-plugin.php In der Hauptdatei schreiben wir normalerweise nicht direkt die Geschäftslogik, sondern verwenden sie als “Startprogramm” („Launcher“), das die notwendigen Dateien enthält und die Kernklassen initialisiert.
// 防止直接文件访问
if ( ! defined( 'ABSPATH' ) ) {
exit;
}
// 定义插件路径常量，方便在其他文件中引用
define( 'MY_PLUGIN_PATH', plugin_dir_path( __FILE__ ) );
define( 'MY_PLUGIN_URL', plugin_dir_url( __FILE__ ) );
// 包含核心类文件
require_once MY_PLUGIN_PATH . 'includes/class-core.php';
require_once MY_PLUGIN_PATH . 'includes/class-admin.php';
// 初始化插件
function my_custom_plugin_init() {
$plugin_core = new My_Plugin_Core();
$plugin_admin = new My_Plugin_Admin();
// 执行初始化操作...
}
add_action( 'plugins_loaded', 'my_custom_plugin_init' );Verbinden Sie mit dem WordPress-Kern: Aktionen und Filter-Hooks
Das Plugin-System von WordPress ist so leistungsfähig, weil es eine große Anzahl von Ereignispunkten bietet, die es Entwicklern ermöglichen, das Verhalten von WordPress zu ändern oder zu erweitern, ohne den Kerncode zu modifizieren. Diese Mechanismen werden “Hooks” genannt und unterteilen sich hauptsächlich in „Actions“ und „Filters“. Sie bilden die Verbindung zwischen Plugins und dem WordPress-Kern.
Verstehen und Anwenden von Action-Hooks
Action Hooks ermöglichen es Ihnen, benutzerdefinierten Code auszuführen, sobald ein bestimmtes Ereignis eintritt – beispielsweise wenn ein Artikel veröffentlicht wird, wenn ein Benutzer sich anmeldet oder wenn eine Seite im Administrationsbereich geladen wird. add_action() Funktionen können Ihre eigenen Funktionen an diese “Hook-Points” (Anknüpfungspunkte) „montieren“ (d.h. sie dort einbinden).
Angenommen, Sie möchten am Ende eines Artikels automatisch eine Urheberrechtsangabe hinzufügen – dafür können Sie folgende Methoden verwenden: the_content Dieser „Action-Hook“ (tatsächlich handelt es sich dabei um einen Filter, aber die Verwendung ähnelt der eines Actions; klassische Beispiele verwenden diese Bezeichnung) eignet sich besonders gut, um nach dem erfolgreichen Registrieren eines Benutzers eine Willkommens-E-Mail zu senden:
// 这是一个动作钩子的使用示例
function my_plugin_send_welcome_email( $user_id ) {
$user = get_userdata( $user_id );
$to = $user->user_email;
$subject = '欢迎加入我们的网站！';
$message = '亲爱的' . $user->display_name . '，感谢您注册！';
wp_mail( $to, $subject, $message );
}
// 将函数挂载到`user_register`这个动作钩子上
add_action( 'user_register', 'my_plugin_send_welcome_email' );Die Nutzung von Filtern beherrschen
Filter-Hooks ermöglichen es Ihnen, Daten zu ändern. Wenn WordPress einen bestimmten Prozess ausführt, werden spezifische Daten an eine Reihe von Filtern weitergeleitet. Ihr Plugin kann diese Daten abfangen, modifizieren und anschließend wieder zurückgeben. add_filter() Diese Funktion wird verwendet, um dies zu realisieren.
Das häufigste Beispiel ist die Anpassung der Ausgabe des Artikelinhalts. Zum Beispiel wird vor jedem Artikelinhalt automatisch ein spezielles Bild als Leitbild hinzugefügt.
Empfohlene Lektüre Einführung in die Entwicklung von WordPress-Plugins: Erstellen Sie Ihr erstes benutzerdefiniertes Funktionsmodul von Grund auf。
function my_plugin_prepend_featured_image_to_content( $content ) {
// 只在主循环的单篇文章页面生效
if ( is_single() && in_the_loop() && is_main_query() ) {
$featured_image = get_the_post_thumbnail( null, 'medium', array( 'class' => 'alignleft' ) );
if ( $featured_image ) {
$content = $featured_image . $content;
}
}
return $content;
}
// 将函数挂载到`the_content`这个过滤器钩子上
add_filter( 'the_content', 'my_plugin_prepend_featured_image_to_content' );Implementierung der Plugin-Funktion: Integration von Backend und Frontend
Ein vollständiges Plugin benötigt in der Regel die Interaktion mit dem Benutzer – das bedeutet, dass Sie eine Verwaltungsoberfläche erstellen müssen, um Einstellungen zu verwalten, sowie möglicherweise neue Funktionen oder Inhalte auf der Benutzeroberfläche hinzuzufügen.
Erstellung einer Seite für die Hintergrundeinstellungen
Es ist entscheidend für ein gutes Benutzererlebnis, dass Plugins eine klare Backend-Einstellungsseite bieten. WordPress stellt verschiedene APIs zur Verfügung, um oberste Menüs oder Untermenüs hinzuzufügen. Der Prozess umfasst in der Regel zwei Schritte: Die Registrierung von Menüeinträgen sowie die Definition von Callback-Funktionen für diese Menüeinträge, die die Inhalte der jeweiligen Seiten ausgeben.
Hier ist ein Beispiel dafür, wie man unter dem Hauptmenü “Einstellungen” ein Untermenü hinzufügt:
class My_Plugin_Admin {
public function __construct() {
add_action( 'admin_menu', array( $this, 'add_admin_menu' ) );
add_action( 'admin_init', array( $this, 'register_settings' ) );
}
public function add_admin_menu() {
add_options_page(
'我的插件设置', // 页面标题
'我的插件', // 菜单标题
'manage_options', // 所需权限
'my-plugin-settings', // 菜单slug
array( $this, 'render_settings_page' ) // 回调函数
);
}
public function register_settings() {
// 注册一个设置选项
register_setting( 'my_plugin_settings_group', 'my_plugin_option_name' );
// 添加一个设置区块
add_settings_section( 'my_plugin_main_section', '主要设置', null, 'my-plugin-settings' );
// 向区块中添加一个字段
add_settings_field(
'my_plugin_text_field',
'示例文本字段',
array( $this, 'render_text_field' ),
'my-plugin-settings',
'my_plugin_main_section'
);
}
public function render_settings_page() {
?>
<div class="wrap">
<h1>Meine Plugin-Einstellungen</h1>
<form action="/de/options.php/" method="post" data-trp-original-action="options.php">
<p><strong>Dies ist ein PHP-Codebeispiel für die Verwendung der Funktionen settings_fields() und do_settings_sections() zur Konfiguration von Einstellungen für ein WordPress-Plugin.</strong></p>
<input type="hidden" name="trp-form-language" value="de"/></form>
</div>
<?php
}
public function render_text_field() {
$option = get_option( 'my_plugin_option_name' );
echo '<input type="text" name="my_plugin_option_name" value="' . esc_attr( $option ) . '" />';
}
}Die Funktionen sollen an die Website-Frontend- Seite ausgegeben werden.
Es gibt verschiedene Möglichkeiten, Frontend-Funktionen umzusetzen: Entweder durch Shortcodes, Widgets oder durch die Anpassung der vorhandenen Ausgabe über APIs. Shortcodes sind eine einfache und effektive Methode, die es Benutzern ermöglicht, Plug-in-Funktionen in Artikeln oder Seiteneditoren durch die Eingabe eines einfachen Tags aufzurufen.
Um Shortcodes zu erstellen, ist es notwendig, bestimmte Werkzeuge oder Methoden zu verwenden. add_shortcode() Funktion:
// 定义一个简单的短代码，用于显示一个问候语
function my_plugin_greeting_shortcode( $atts ) {
// 解析短代码属性
$atts = shortcode_atts( array(
'name' => '访客',
), $atts, 'greeting' );
// 返回输出内容
return '<p class="my-plugin-greeting">Hallo, '. esc_html($atts['name'])'. ‘!</p>';
}
add_shortcode( 'greeting', 'my_plugin_greeting_shortcode' );Die Benutzer müssen lediglich im Artikel-Editor den Text eingeben. [greeting name="张三"]Dann wird auf der Benutzeroberfläche der Absatz “Hallo, Zhang San!” angezeigt.
Zusammenfassungen
Die Entwicklung von WordPress-Plugins ist ein Prozess, bei dem eigene Ideen in ein umfangreiches Ökosystem eingeführt werden. Die Kerntechnologien dabei liegen in der Verständnis und Anwendung von Aktionen (Actions) sowie Filter-Hooks. Eine erfolgreiche Entwicklung beginnt mit einer klaren, modularen Dateistruktur, die eine solide Grundlage für spätere Wartung und Erweiterungen schafft. Durch die Erstellung von Backend-Einstellungsseiten können Plugins benutzerfreundlich und einfach konfiguriert werden; Funktionen können außerdem mithilfe von Shortcodes, Widgets oder benutzerdefinierten APIs nahtlos in die Frontend-Struktur der Website integriert werden. Sicherheit, Internationalisierbarkeit und Codequalität sind während des gesamten Entwicklungsprozesses von großer Bedeutung. Die Einhaltung der WordPress-Codestandards und -Best Practices sorgt nicht nur für einen stabilen Betrieb der Plugins, sondern auch dafür, dass sie besser in das Ökosystem integriert werden und so mehr Nutzern zugutekommen.
FAQ Häufig gestellte Fragen
Welche PHP-Kenntnisse sind für die Entwicklung von WordPress-Plugins erforderlich?
Um einen einfachen Plugin zu entwickeln, reichen grundlegende Kenntnisse von PHP aus – beispielsweise von Variablen, Funktionen, Bedingungssätzen und Schleifen. Für die Entwicklung von komplexen, sicheren und effizienten kommerziellen Plugins ist jedoch ein tieferes Verständnis erforderlich, einschließlich, aber nicht beschränkt auf Objektorientierte Programmierung (OOP) sowie der WordPress-Core-API (z. B. für Datenbankoperationen). wpdbHTTP-Request-APIs, Sicherheitsbest Practices (wie Datenvalidierung, Entschlüsselung, Schutz vor SQL-Injection- und CSRF-Angriffen), sowie grundlegende Kenntnisse in JavaScript und CSS für die Frontend-Interaktionen sind erforderlich.
Es wird empfohlen, mit der Modifizierung bestehender kleiner Plugins oder dem Erstellen einfacher Funktionen zu beginnen und sich anschließend schrittweise tiefer in das Thema einzuarbeiten.
Wie kann ich sicherstellen, dass die von mir entwickelte Erweiterung sicher ist?
Die Sicherstellung der Sicherheit von Plugins ist eine vielschichtige Aufgabe. Zunächst einmal ist es wichtig, alle von Benutzern oder externen Quellen stammenden Eingaben – wie Formulardaten, URL-Parameter und Cookies – streng zu überprüfen und zu bereinigen. Hierfür können Funktionen verwendet werden, die von WordPress bereitgestellt werden. sanitize_text_field(), esc_html(), esc_url() und wp_kses() usw.
Zweitens ist es beim Ausführen von Datenbankoperationen unerlässlich, sicherzustellen, dass… $wpdb Die von der Klasse bereitgestellten Methoden (z. B.) prepare() Um SQL-Injectionen zu verhindern, werden spezielle Mechanismen (z. B. Parameterisierung) eingesetzt. Bevor jegliche Daten an die Benutzeroberfläche ausgegeben werden, müssen diese entsprechend entschlossen werden („escaped“). Bei Operationen, die Berechtigungen erfordern, sollten stets Funktionen zur Überprüfung der Berechtigungen („permission checking functions“) verwendet werden. current_user_can()Darüber hinaus wird ein nicht-zufällig generierter Wert („nonce“) verwendet, um die Absicht der Anfrage zu überprüfen und so das Phänomen der Cross-Site-Request-Forgery (CSRF) zu verhindern.
Nachdem die Entwicklung eines Plugins abgeschlossen ist, wie wird es dann verteilt und aktualisiert?
Es gibt hauptsächlich zwei Möglichkeiten, Plugins zu verteilen: Entweder über den offiziellen WordPress-Plugin-Verzeichnis oder direkt auf eigenen Webseiten zum Download anzubieten. Wenn Sie möchten, dass die Plugins von den Nutzern über die Benutzeroberfläche mit nur einem Klick installiert werden und automatisch aktualisiert werden, müssen sie in das offizielle Verzeichnis eingereicht werden. Dies setzt voraus, dass der Plugin-Code unter der GPLv2-Lizenz (oder einer höheren Version) steht und dass er einer strengen Sicherheits- sowie Codequalitätsprüfung unterzogen wird.
Nach dem Absenden deines Plugins wird WordPress den Code aus seinem offiziellen Subversion (SVN) Repository laden. Um eine Benachrichtigung über die Aktualisierung auszulösen, musst du die “Version”-Angabe in den Kommentaren der Hauptdatei im SVN-Repository aktualisieren und anschließend einen neuen Tag mit der neuen Versionszahl einreichen.
Für kommerzielle Plugins wird in der Regel ein eigenes Update-Service-System auf dem eigenen Server eingerichtet. Dazu gehört die Entwicklung eines Update-Checkers, der mithilfe von Hook-Funktionen (z. B.) die Verfügbarkeit neuer Updates überwacht und diese dann automatisch installiert. pre_set_site_transient_update_pluginsEs wird mit dem Update-System von WordPress integriert, vergleicht die Versionsinformationen auf dem entfernten Server und stellt Update-Pakete zur Verfügung.
Wie kann man vermeiden, dass die Klassennamen und Funktionsnamen in einem Plugin mit denen anderer Plugins in Konflikt geraten?
Das Vermeiden von Namenskonflikten ist eine grundlegende Anforderung bei der Entwicklung professioneller Plugins. Die beste Praxis besteht darin, Präfixe zu verwenden. Verwende für alle Klassen, Funktionen, Konstanten – und sogar für globale Variablen (die so weit wie möglich vermieden werden sollten) – ein einzigartiges und beschreibendes Präfix. Dieses Präfix kann in der Regel eine Abkürzung oder die vollständige Bezeichnung deines Unternehmens oder des Namens deines Plugins sein.
Zum Beispiel könnte, wenn Ihre Erweiterung “Awesome Gallery” heißt, der Präfix Ihrer Funktion lauten… ag_ oder awesome_gallery_Die Klassennamen können beliebig sein. AG_Core oder Awesome_Gallery_Admin。
Die bessere Vorgehensweise besteht darin, den Code in eine Klasse zu verpacken. Dadurch existieren die meisten Funktionen in Form von Klassenmethoden. $this->method()Damit wird eine Verschmutzung des globalen Namensraums verhindert. Für Funktionen, die unbedingt im globalen Raum definiert werden müssen, sollte unbedingt ein langes und einzigartiges Präfix verwendet werden.
Was kommt als Nächstes, was kommt als Nächstes?
Erweiterte Lektüre und praktische Kenntnisse
Die folgenden Artikel stehen im Zusammenhang mit dem Thema dieses Artikels und eignen sich für eine vertiefte Lektüre. Oft ist es besser, mit dem Artikel zu beginnen, der Ihrem aktuellen Problem am nächsten kommt, und dann nach und nach die umliegenden Themen zu behandeln.
- WordPress-Plugin-Entwicklungshandbuch: Von Null zu Eins – Erstellen Sie Ihr erstes benutzerdefinierte Plugin
- Wie man ein WordPress-Plugin-Entwickler wird: Ein umfassender Leitfaden von Grund auf
- Komplettanleitung zur Entwicklung von WordPress-Plugins: Von der Grundlagenkenntnis bis zur Meisterschaft – Erstellen Sie professionelle Erweiterungen
- WordPress-Plugin-Entwicklung von der Grundlage bis zur Meisterschaft: Erstellen Sie Ihr erstes benutzerdefiniertes Plugin
- Vom Nullpunkt zum Erreichen des ersten Erfolgs: Ein umfassender Leitfaden zur schrittweisen Entwicklung deines ersten WordPress-Plugins
Deutsch