Eine vollständige Anleitung zur Entwicklung von WordPress-Plugins: Von den Grundlagen bis hin zu fortgeschrittenen praktischen Tutorials

Ob Sie bestimmte Funktionen zu Ihrer Website hinzufügen oder Ihre Ideen in ein teilbares Produkt umsetzen möchten – das Erlernen der WordPress-Plugin-Entwicklung ist eine äußerst wertvolle Fertigkeit. Durch die selbstständige Entwicklung von Plugins erhalten Sie die vollständige Kontrolle über die Funktionen Ihrer Website, gehen über die Einschränkungen von Themes hinaus und tragen letztendlich zum riesigen WordPress-Ökosystem bei. Diese Anleitung führt Sie Schritt für Schritt durch den gesamten Prozess, von der Einrichtung einer Entwicklungsumgebung bis zur Veröffentlichung fortgeschrittener Plugins, und vermittelt Ihnen alles, was Sie zum Erstellen leistungsstarker, sicherer und wartbarer Plugins benötigen.

Aufbau der Entwicklungsumgebung und Initialisierung des Projekts

Bevor Sie die erste Codezeile schreiben, ist es von entscheidender Bedeutung, eine effiziente Entwicklungsumgebung einzurichten. Eine gut konfigurierte Umgebung kann Ihre Entwicklungseffizienz und Ihr Debugging-Erlebnis erheblich verbessern.

Konfiguration der lokalen Entwicklungsumgebung

Es wird empfohlen, lokale Server-Umgebungssoftwarepakete wie Local by Flywheel, XAMPP oder Laragon zu verwenden. Diese Tools können PHP, MySQL und Webserver (in der Regel Apache oder Nginx) mit einem einzigen Klick installieren. Stellen Sie sicher, dass Ihre PHP-Version der offiziell empfohlenen Version entspricht. Das WordPress-Kernteam empfiehlt normalerweise die Verwendung einer stabilen PHP-Version.

Empfohlene Lektüre Die ultimative Anleitung zur Entwicklung von WordPress-Plugins: Benutzerdefinierte Funktionen von Grund auf erstellen。

Als Nächstes benötigen Sie einen Code-Editor. Visual Studio Code und PhpStorm sind bei Entwicklern beliebt. VS Code ist leichtgewichtig und sehr erweiterbar und bietet durch die Installation von Erweiterungen wie PHP Intelephense und WordPress-Code-Snippets ein fast IDE-ähnliches Erlebnis. PhpStorm hingegen bietet leistungsstärkere Tools für Code-Analyse, Debugging und Refactoring.

UltaHost – WordPress-Hosting-Anbieter

30-tägige Geld-zurück-Garantie, unbegrenztes Bandbreiten- und Datenbankvolumen, kostenlose DDoS-Schutzmaßnahmen sowie ein Rabatt von 501 auf 4 Terabyte bei einer Kaufdauer von 3 Jahren.

Zugangsseite

Erstellung der Grundstruktur für das erste Plugin

Ein WordPress-Plugin ist im Wesentlichen ein Element, das sich auf der wp-content/plugins/ Die Ordner im Verzeichnis, die mindestens eine PHP-Hauptdatei enthalten. Lassen Sie uns mit der Erstellung eines sehr einfachen Plugins beginnen.

Zunächst erstellen Sie einen neuen Ordner im Plugin-Verzeichnis Ihrer lokalen WordPress-Installation, z. B. my-first-pluginIn diesem Ordner erstellen Sie eine Haupt-PHP-Datei, deren Name normalerweise mit dem Namen des Ordners übereinstimmt:my-first-plugin.php。

Jedes Plugin muss mit standardmäßigen Plugin-Header-Informationen beginnen, da WordPress auf diese Weise die grundlegenden Informationen zum Plugin erkennt. Öffnen Sie my-first-plugin.php Und geben Sie den folgenden Code ein:

<?php
/**
 * Plugin Name:       我的第一个插件
 * Plugin URI:        https://yourwebsite.com/my-first-plugin
 * Description:       这是一个用于学习的简单示例插件。
 * Version:           1.0.0
 * Author:            你的名字
 * License:           GPL v2 or later
 * Text Domain:       my-first-plugin
 * Domain Path:       /languages
 */

Nachdem Sie die Datei gespeichert haben, melden Sie sich in Ihrem WordPress-Dashboard an und gehen Sie zum Menü “Plugins”. Sie sollten “Mein erstes Plugin” in der Plugin-Liste sehen. Obwohl es derzeit keine Funktionen hat, haben Sie erfolgreich ein funktionierendes WordPress-Plugin erstellt.

Empfohlene Lektüre Das ultimative Handbuch für die Entwicklung von WordPress-Plugins: Von der Grundlage bis zur Erstellung von kommerziell nutzbaren Plugins。

Die Kernstruktur des Plugins und der Hook-Mechanismus

Das Verständnis des “Hooks”-Systems von WordPress ist der Grundstein für die Entwicklung von Plugins. Hooks ermöglichen es Ihrem Code, zu bestimmten Zeitpunkten in den Kernprozess von WordPress “eingehängt” zu werden, um Funktionen zu ändern oder hinzuzufügen.

Action Hooks und Filter Hooks

WordPress bietet zwei Haupttypen von Hooks: Aktionen (Actions) und Filter (Filters).

Aktions-Hooks ermöglichen es Ihnen, Code auszuführen, wenn bestimmte Ereignisse eintreten, z. B. das Veröffentlichen eines Artikels, die Anmeldung eines Benutzers oder das Laden des Administrationsbereichs. Sie erwarten keinen Rückgabewert, sondern dienen dazu, “etwas zu tun”. Verwenden Sie add_action() Eine Funktion, um Ihre Funktion an einen Aktions-Hook zu binden.

hosting.com Shared Hosting

Hohe Leistung mit AMD EPYC-CPUs, NVMe-SSD-Speicher und LiteSpeed, fachkundiger Inhouse-Support rund um die Uhr, erweiterte Sicherheitsmaßnahmen einschließlich SSL, Brute-Force-, Malware- und DDoS-Schutz, Einsparungen von bis zu 73%

Zugangsseite

Filter-Haken werden zum Ändern von Daten verwendet. Sie ermöglichen es Ihnen, Daten zu ändern, bevor sie verwendet werden (z. B. in einer Datenbank gespeichert oder auf einer Seite angezeigt werden). Die Filterfunktion muss einen geänderten Wert zurückgeben. Verwenden Sie add_filter() Eine Funktion, um Ihre Funktion an einen Filter-Hook zu binden.

Eine einfache Funktion implementieren

Fügen wir dem Plugin die erste praktische Funktion hinzu: Am Ende des Beitragsinhalts automatisch einen benutzerdefinierten Textabschnitt hinzufügen. Wir werden dafür verwenden the_content Dieser Filter-Hook.

In deinem my-first-plugin.php Nach dem Kommentarblock am Anfang der Datei fügen Sie den folgenden Code hinzu:

Empfohlene Lektüre Lernen Sie WordPress-Plugins von Grund auf entwickeln: Erstellen Sie Ihre erste benutzerdefinierte Funktion。

// 在文章内容后添加自定义文本
function myfp_add_text_to_content( $content ) {
    if ( is_single() && in_the_loop() && is_main_query() ) {
        $custom_text = '<p><em>Vielen Dank für das Lesen! Dieser Artikel wird von [Mein erstes Plugin] unterstützt.</em></p>';
        $content .= $custom_text;
    }
    return $content;
}
add_filter( 'the_content', 'myfp_add_text_to_content' );

Dieser Code definiert eine Funktion. myfp_add_text_to_contentEs empfängt den Inhalt der Artikel. $content Als Parameter. Die Bedingungsprüfung innerhalb der Funktion stellt sicher, dass dieser Text nur in der Hauptschleife der einzelnen Artikelseite im Frontend angezeigt wird. Anschließend fügen wir den angepassten Text zum ursprünglichen Inhalt hinzu und geben den geänderten Inhalt zurück. In der letzten Zeile wird < verwendet. add_filter Laden Sie diese Funktion in the_content Auf dem Filter.

Speichern Sie die Datei und aktualisieren Sie die Seite eines Blog-Artikels. Sie werden dann den hinzugefügten Text am Ende des Artikels sehen.

InterServer Shared Hosting

Shared Hosting $2.50 USD pro Monat, erster Monat $0.1 USD Promo-Code tryinterserver, 461 Cloud-Apps Skripte, ein Klick installieren.

Zugangsseite

Erstellung eines Verwaltungsmenüs und einer Einstellungsseite

Ein vollständiges Plugin muss dem Benutzer in der Regel Konfigurationsoptionen bieten. Dazu müssen im WordPress-Administrationsbereich Menüs und Einstellungsseiten erstellt werden.

Fügen Sie die Seite zum Verwaltungsmenü hinzu.

WordPress bietet Funktionen zum Hinzufügen von Haupt- oder Untermenüs in der Verwaltungs-Seitenleiste. Wir werden eine einfache Einstellungsseite erstellen. Zunächst verwenden wir add_action() Der Haken ist in admin_menu Dieser Aktion wird eine Funktion hinzugefügt, die zum Registrieren des Menüs verwendet wird.

Fügen Sie den folgenden Code in die Hauptdatei des Plugins ein:

// 创建管理菜单
function myfp_create_admin_menu() {
    add_menu_page(
        '我的插件设置',          // 页面标题
        '我的插件',             // 菜单标题
        'manage_options',       // 所需权限
        'myfp-settings',        // 菜单 Slug
        'myfp_settings_page_html', // 显示页面内容的回调函数
        'dashicons-admin-generic', // 菜单图标（Dashicon）
        80                      // 菜单位置
    );
}
add_action( 'admin_menu', 'myfp_create_admin_menu' );

Erstellen Sie die Inhalte der Einstellungsseite.

Jetzt müssen wir den obigen Callback-Funktion definieren. myfp_settings_page_html Um den HTML-Inhalt der Einstellungsseite zu rendern.

// Festlegung der HTML-Struktur der Einstellungsseite
function myfp_settings_page_html() {
    // Überprüfung der Benutzerberechtigungen
    if ( ! current_user_can( 'manage_options' ) ) {
        return;
    }
    ?>
    <div class="wrap">
        <h1>\n</h1>
        <form action="/de/options.php/" method="post" data-trp-original-action="options.php">
            <?php
            // 输出安全字段（如 nonce）、设置节和字段
            settings_fields( 'myfp_options' );
            do_settings_sections( 'myfp-settings' );
            submit_button( '保存设置' );
            ?>
        <input type="hidden" name="trp-form-language" value="de"/></form>
    </div>
    &lt;?php
}

Um Einstellungen zu speichern und zu überprüfen, müssen wir die WordPress-Einstellungs-API verwenden. Dazu müssen wir Einstellungen registrieren und Abschnitte (sections) sowie Felder (fields) hinzufügen. Lassen Sie uns diese Einstellungen in einer anderen Funktion initialisieren und anhängen. admin_init Aktion.

// 初始化设置
function myfp_settings_init() {
    // 注册一个设置项
    register_setting( 'myfp_options', 'myfp_options', 'myfp_options_validate' );

// 添加一个设置区域
    add_settings_section(
        'myfp_section_general',
        '常规设置',
        'myfp_section_general_html',
        'myfp-settings'
    );

// 向该区域添加一个字段
    add_settings_field(
        'myfp_field_custom_text',
        '自定义显示文本',
        'myfp_field_custom_text_html',
        'myfp-settings',
        'myfp_section_general',
        [ 'label_for' => 'myfp_field_custom_text' ]
    );
}
add_action( 'admin_init', 'myfp_settings_init' );

// 设置区域的描述文本
function myfp_section_general_html() {
    echo '<p>Konfigurieren Sie das grundlegende Verhalten des Plugins.</p>';
}

// 文本字段的 HTML 输出
function myfp_field_custom_text_html() {
    $options = get_option( 'myfp_options' );
    $value = $options['custom_text'] ?? ''; // 使用空值合并运算符
    ?&gt;
    <input type="text" id="myfp_field_custom_text" name="myfp_options[custom_text]" value="<?php echo esc_attr( $value ); ?>" class="regular-text">
    <p class="description">Der hier eingegebene Text wird am Ende des Artikels angezeigt.</p>
    &lt;?php
}

// Einfache Validierung der Einstellungen
function myfp_options_validate( $input ) {
    $new_input = [];
    if (isset( $input[&#039;custom_text&#039;] )) {
        $new_input[&#039;custom_text&#039;] = sanitize_text_field( $input[&#039;custom_text&#039;] );
    }
    return $new_input;
}

Zuletzt sollten Sie nicht vergessen, die von uns zuvor erstellten Änderungen vorzunehmen. myfp_add_text_to_content Funktion, lassen Sie sie diese neue Einstellung verwenden.

function myfp_add_text_to_content( $content ) {
    if ( is_single() && in_the_loop() && is_main_query() ) {
        $options = get_option( 'myfp_options' );
        $custom_text = $options['custom_text'] ???? 'Danke fürs Lesen!' ;
        // Vor dem Hinzufügen sicherstellen, dass ein Inhalt vorhanden ist
        if ( ! empty( $custom_text ) ) {
            $content . = '<p><em>'`. esc_html($custom_text)`.'</em></p>';
        }
    }
    return $content.
}

Jetzt können Sie den Text, der am Ende des Artikels angezeigt wird, auf der Einstellungsseite des Plugins frei bearbeiten.

Erweiterte Entwicklung und Best Practices

Wenn die Funktionalität des Plugins zunehmend komplexer wird, kann die Einhaltung guter Entwicklungspraktiken die Wartbarkeit, Sicherheit und Leistung des Codes gewährleisten.

Objektorientierte Programmierung und Sicherheit

Für komplexe Plugins ist die Verwendung einer objektorientierten (OOP) Klassenstruktur die bessere Wahl. Dies hilft, den Code zu organisieren, Konflikte bei Funktionsnamen zu vermeiden und die Wiederverwendbarkeit zu verbessern.

Eine einfache Klassenstruktur sieht beispielsweise wie folgt aus:

class MyFirstPlugin {
    public function __construct() {
        add_action( 'init', [ $this, 'load_textdomain' ] );
        add_action( 'admin_menu', [ $this, 'create_admin_menu' ] );
        add_filter( 'the_content', [ $this, 'add_text_to_content' ] );
    }

public function load_textdomain() {
        load_plugin_textdomain( 'my-first-plugin', false, dirname( plugin_basename( __FILE__ ) ) . '/languages' );
    }

// ... 其他方法（如前面定义的函数可以移到这里成为类的方法）...
}

// 安全地初始化插件类
if ( class_exists( 'MyFirstPlugin' ) ) {
    $myFirstPlugin = new MyFirstPlugin();
}

Sicherheit hat bei der WordPress-Entwicklung höchste Priorität. Validieren (Validation) und bereinigen (Sanitization) Sie Benutzereingaben stets und escapen (Escaping) Sie Ausgaben. Verwenden Sie Funktionen wie sanitize_text_field(), esc_html(), wp_kses_post() und wp_nonce_field() So eine eingebaute Funktion von WordPress.

Internationale Ausrichtung und Leistungsoptimierung

Damit Ihr Plugin von Nutzern auf der ganzen Welt verwendet werden kann, ist Internationalisierung (i18n) unerlässlich. Das bedeutet, dass Sie __() und _e() Verwenden Sie Funktionen wie diese, um alle für den Benutzer sichtbaren Zeichenfolgen zu umschließen. Wir haben dies bereits im Konstruktor der Klasse eingebunden. load_textdomain Eine Funktion, die dies tun wird. init Sie laden die Übersetzungsdateien während der Aktion. Sie müssen Tools wie Poedit verwenden, um sie zu erstellen. .pot Erzeugen Sie Vorlagendateien und lassen Sie Übersetzer sie erstellen. .mo Translate the file.

Im Hinblick auf die Leistung ist es wichtig, sicherzustellen, dass Plugin-Ressourcen (wie CSS- und JS-Dateien) nur dann geladen werden, wenn dies erforderlich ist. Verwenden Sie hierfür wp_enqueue_script() und wp_enqueue_style() Eine Funktion und die Verwendung der richtigen Hooks (wie z. B. wp_enqueue_scripts Für den Empfangsbereich,admin_enqueue_scripts (Für den Hintergrund). Für Datenbankabfragen sollten Sie möglichst das Caching-API von WordPress verwenden (z. B. wp_cache_get() und wp_cache_set()）, um die Ergebnisse zeitaufwändiger Vorgänge zwischenzuspeichern.

Zusammenfassungen

Die Reise zur Entwicklung von WordPress-Plugins beginnt mit einer einfachen PHP-Datei. Durch das Beherrschen der Mechanismen von Aktionen und Filtern erhalten Sie die Fähigkeit, die Kernfunktionen von WordPress zu ändern und zu erweitern. Von der Erstellung von Verwaltungsoberflächen über die Verwendung der Settings-API zur Verwaltung von Benutzereinstellungen bis hin zur Anwendung von objektorientierter Programmierung und strengen Sicherheitspraktiken verbessert jeder Schritt die Professionalität und Zuverlässigkeit des Plugins. Denken Sie daran, dass ein hervorragendes Plugin nicht nur leistungsstark sein muss, sondern auch internationale Best Practices, Leistungsoptimierung und Code-Organisation befolgen muss, um sicher, effizient und einfach zu warten zu sein. Während Sie weiter üben, werden Sie in der Lage sein, qualitativ hochwertige Plugins zu erstellen, die komplexe Anforderungen erfüllen und für die globale WordPress-Community verfügbar sind.

FAQ Häufig gestellte Fragen

Welche Grundkenntnisse sind für die Entwicklung von WordPress-Plugins erforderlich?

Sie müssen die grundlegende Syntax der Programmiersprache PHP beherrschen und die Rolle von HTML, CSS und JavaScript bei der Interaktion mit der Benutzeroberfläche verstehen. Die Kenntnis der Grundkonzepte von WordPress, wie Artikel, Seiten, Benutzerrollen und Datenbankstruktur, wird Ihnen dabei helfen zu verstehen, wie Plugins mit dem System interagieren. Ein grundlegendes Verständnis von HTTP-Anfragen und -Antworten wird ebenfalls hilfreich sein, wenn es um die Verarbeitung von Formularen und API-Aufrufen geht.

Was ist der Unterschied zwischen Aktionen und Filtern in Hooks?

Aktions-Hooks werden verwendet, um Ihren Code bei bestimmten Ereignissen auszuführen. Sie geben keinen Wert zurück, sondern dienen dazu, “etwas zu tun”, z. B. eine E-Mail zu senden oder ein Protokoll zu erstellen. Filter-Hooks werden verwendet, um die an sie übermittelten Daten zu ändern. Ihre Funktion muss einen geänderten Wert zurückgeben, der den Inhalt, den Text oder andere Variablen ändert, z. B. die Änderung des Artikeltitels oder des Widget-Inhalts.

Wie kann ich verhindern, dass das von mir entwickelte Plugin mit anderen Plugins in Konflikt gerät?

Das Hinzufügen eines eindeutigen Präfixes für alle Ihre Funktionen, Klassen, Variablen und Konstanten ist der effektivste Weg, um Namenskonflikte zu vermeiden. Vermeiden Sie die Verwendung allgemeiner Namen und verwenden Sie stattdessen ein Kürzel, das Ihr Plugin oder Ihr Unternehmen repräsentiert. Die Verwendung von objektorientierter Programmierung und die Einbettung von Code in Klassen können ebenfalls dazu beitragen, Bereiche effektiv zu isolieren. Außerdem sollten Sie bei der Einbindung von Hooks sicherstellen, dass die Bedingungsprüfungen korrekt sind, um zu verhindern, dass Ihr Code auf unnötigen Seiten geladen wird.

Wie soll ich mein WordPress-Plug-in debuggen?

Zunächst stellen Sie sicher, dass auf wp-config.php Die Datei wurde geöffnet. WP_DEBUG und WP_DEBUG_LOGDas wird PHP-Fehler, Benachrichtigungen und Warnungen aufzeichnen. wp-content/debug.log Im File. Verwenden Sie es. error_log() Der Funktionsausgabe-Wert wird zur Fehlersuche verwendet. Die Konsole und das Netzwerk-Panel der Browser-Entwicklerwerkzeuge sind für die Fehlersuche bei JavaScript und AJAX-Anfragen von entscheidender Bedeutung. Bei komplexen Problemen kann die Verwendung professioneller Debugging-Tools wie Xdebug die Effizienz erheblich steigern.

Nachdem die Entwicklung abgeschlossen ist, wie kann ich mein Plugin im offiziellen Katalog veröffentlichen?

Sie müssen die offizielle Entwicklerplattform von WordPress besuchen und ein Konto erstellen. Lesen Sie die „Anleitung für Plugin-Entwickler“ sorgfältig durch und stellen Sie sicher, dass Ihr Plugin alle Anforderungen erfüllt, einschließlich der Codestandards, der Sicherheit und der Lizenz (die mit GPL kompatibel sein muss). Bereiten Sie eine Beschreibung des Plugins, Screenshots und eine README-Datei vor. Anschließend übermitteln Sie Ihren Code über Subversion (SVN) an das offizielle Repository, das Ihnen zugewiesen wurde, und es wird dann im Verzeichnis angezeigt.