Volledig in de kunst van WordPress-pluginontwikkeling: van nul beginnen met het bouwen van aangepaste functionaliteiten

Vanaf nul: voorbereidende werkzaamheden en opzet van de omgeving

Voordat je begint met het schrijven van je eerste plugin, moet je eerst alle benodigde voorbereidingen treffen. Dit omvat het begrijpen van de basisstructuur van WordPress-plugins, het instellen van een veilige lokale ontwikkelomgeving en het begrijpen van de kernfilosofie van pluginontwikkeling.

Een typisch WordPress-plugin is een bestand dat zich bevindt in de map `plugins` in het WordPress-installatieverkeer. /wp-content/plugins/ De map bevat een afzonderlijke map. Het kernpunt hiervan is een PHP-hoofdbestand met een specifiek bestandsheader. Dit hoofdbestand bevat niet alleen de meta-informatie van het plugin, maar vormt ook de entreepunt voor alle functionaliteiten van het plugin. Er zijn twee manieren om het plugin te starten: ofwel door een combinatie van procedurerende functies te gebruiken, ofwel door een objectgerichte klassestructuur te hanteren. De laatste methode wordt steeds meer gebruikt in moderne pluginontwikkeling vanwege de betere afsluiting van onderdelen van het codepatroon en de betere organisatie van de code.

Een lokale ontwikkelomgeving is van essentieel belang voor efficiënte ontwikkeling. Het wordt aanbevolen om tools als XAMPP, Local by Flywheel of Docker te gebruiken om een omgeving op te bouwen waarin Apache/Nginx, MySQL en PHP zijn geïntegreerd. Dit biedt je de mogelijkheid om vrij te testen en te debuggen zonder dat je de online website beïnvloedt.

Aanbevolen leesmateriaal Van nul beginnen: een volledig handboek voor het ontwikkelen van WordPress-plug-ins en tips en beste praktijken。

Constructie van een plugin-skelet: structuur en kernbestanden

In deze sectie wordt uitgebreid beschreven hoe je vanaf nul een basispakket voor een plugin kunt maken dat voldoet aan de specificaties van WordPress. Een goede basis voor een plugin vormt de basis voor stabiliteit, veiligheid en onderhoud.

UltaHost WordPress-hosting

30-daagse garantie voor het terugbetalen van het geld, onbeperkt bandbreedte- en databestand, gratis DDoS-beveiliging, en een prijsvoordeel van 50% bij een aankoop van 3 jaar.

toegangspagina

Maak de essentiële hoofdpluginbestanden aan.

Het leven van een plugin begint met een hoofdbestand. De naam van dit bestand is meestal gelijk aan de naam van je plugin-map. Bijvoorbeeld, als de naam van je plugin-map is... my-custom-pluginDan kan de hoofdbestand de naam hebben… my-custom-plugin.phpOp de top van deze bestand moet je een commentaarblock gebruiken dat voldoet aan een specifiek format om de informatie over het plugin aan te geven. Dit is essentieel voor WordPress om het plugin te herkennen en het te weergeven in de administratieve lijst.

Hieronder staat een voorbeeld van een zeer basistekst voor een plugin-hoofdbestand:

<?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 deze commentaar is “Plugin Name” verplicht; de overige velden zijn optioneel, maar het wordt aanbevolen ze in te vullen. “Text Domain” en “Domain Path” worden gebruikt voor de internationalisering (i18n) van de plugin, zodat de plugin later in meerdere talen kan worden vertaald.

De bestanden en mappen voor de organisatie-plugin

Naarmate de mogelijkheden van plugins toenemen, is het niet verstandig om al het codegebruik in één hoofdbestand te verzamelen. Een goed georganiseerde structuur voor plugins omvat meestal meerdere submappen en bestanden. Een veel voorkomende structuur is als volgt:

Aanbevolen leesmateriaal Volledig handboek voor het ontwikkelen van WordPress plugins: een praktische handleiding van nul tot live publicatie。

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             # 插件卸载清理脚本

在 my-custom-plugin.php In het hoofdbestand schrijven we meestal geen directe bedrijfslogica, maar gebruiken het als een “starter” die de benodigde bestanden bevat en de kernklassen initialiseert.

// 防止直接文件访问
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' );

Link naar het WordPress-core: Action- en filterhooks

Het sterke punt van het plugin-systeem van WordPress is dat er een groot aantal gebeurtenissen (events) beschikbaar zijn, waardoor ontwikkelaars de werking van het systeem kunnen veranderen of uitbreiden zonder de kerncode aan te passen. De mechanismen die hiervoor worden gebruikt zijn “hooks”, die voornamelijk worden onderverdeeld in Actions en Filters. Deze hooks vormen de brug tussen plugins en de kern van WordPress.

Het begrijpen en toepassen van action hooks

Action hooks bieden je de mogelijkheid om zelfgemaakte code uit te voeren wanneer een bepaald evenement plaatsvindt. Denk hierbij aan het publiceren van een artikel, het inloggen van een gebruiker of het laden van een bepaalde pagina in het administratieve systeem. add_action() Deze functies kunnen je eigen functies “maken vast” aan deze ‘haakjes’ (of: ze kunnen je functies integreren met deze systemen).

hosting.com gedeelde hosting

Hoge prestaties met AMD EPYC CPU's, NVMe SSD opslag en LiteSpeed, 24/7 deskundige interne ondersteuning, geavanceerde beveiligingsmaatregelen waaronder SSL, bescherming tegen brute kracht, malware en DDoS, besparingen tot 73%

toegangspagina

Stel je voor dat je automatisch een auteursrechtverklaring aan de onderkant van een artikel wilt toevoegen. Hiervoor kun je gebruikmaken van the_content Deze ‘action-hook’ (in feite een filter, maar de gebruiksomschrijving is vergelijkbaar met die van een actie; dit wordt vaak gebruikt in klassieke voorbeelden) is handig om bijvoorbeeld een welkomst-e-mail te sturen naar een gebruiker nadat de registratie is geslaagd:

// 这是一个动作钩子的使用示例
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' );

De manier om filters te gebruiken beheersen

De filter-haken bieden je de mogelijkheid om gegevens te bewerken. Wanneer WordPress een bepaald proces uitvoert, worden bepaalde gegevens door een reeks filters gestuurd. Je plugin kan deze gegevens opvangen, bewerken en vervolgens terugsturen. add_filter() Deze functionaliteit wordt gerealiseerd door een function.

Het meest voorkomende voorbeeld is het aanpassen van de weergave van artikelinhoud. Denk hierbij aan het automatisch toevoegen van een prominente foto als introductieafbeelding aan het begin van elke artikel.

Aanbevolen leesmateriaal WordPress-pluginontwikkeling: Een gids om van nul je eerste custom-functionaliteit te bouwen。

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' );

Implementeren van plugin-functionaliteit: integratie tussen backend en frontend

Een compleet plugin moet meestal met de gebruiker kunnen interageren. Dit betekent dat je een beheerinterface moet maken om instellingen te kunnen bewerken, en dat je ook nieuwe functies of inhoud kunt toevoegen op de front-end-pagina.

Maak een pagina voor het instellen van de backend-instellingen.

Het bieden van een duidelijke backend-instellingssite voor een plugin is van belang voor een goede gebruikerservaring. WordPress beschikt over verschillende API's om een hoofdmenu of submenues toe te voegen. De procedure omvat meestal twee stappen: het registreren van menu-items en het definiëren van een callback-functie voor elk menu-item, waarmee de inhoud van de pagina wordt weergegeven.

InterServer gedeelde hosting

Shared hosting $2.50 USD per maand, eerste maand $0.1 USD promo code tryinterserver, 461 cloud apps scripts, een klik te installeren.

toegangspagina

Hier is een voorbeeld van hoe je een submenü-item toevoegt onder het hoofdmenu “Instellingen”:

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>Mijn plug-ininstellingen</h1>
            <form action="/nl/options.php/" method="post" data-trp-original-action="options.php">
                <?php
                settings_fields( 'my_plugin_settings_group' );
                do_settings_sections( 'my-plugin-settings' );
                submit_button();
                ?>
            <input type="hidden" name="trp-form-language" value="nl"/></form>
        </div>
        &lt;?php
    }

public function render_text_field() {
        $option = get_option( &#039;my_plugin_option_name&#039; );
        echo &#039;<input type="text" name="my_plugin_option_name" value="' . esc_attr( $option ) . '" />';
    }
}

De functionaliteit wordt weergegeven op de front-end van de website.

Er zijn diverse manieren om front-end-functionaliteiten te realiseren: met shortcodes, widgets of door bestaande uitgangsinformatie te bewerken via APIs. Shortcodes zijn een simpel en effectief middel dat gebruikers toestaat om plugin-functionaliteiten op te roepen door een eenvoudige tag in te voeren in een artikel- of pagina-editor.

Om een kort codefragment te maken, moet je gebruikmaken van… add_shortcode() Function:

// 定义一个简单的短代码，用于显示一个问候语
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>'php
add_shortcode('greeting', 'my_plugin_greeting_shortcode');

De gebruiker hoeft alleen maar in de artikeleditor te typen. [greeting name="张三"]Op de front-end wordt dan de tekst “Hallo, Zhang San!” weergegeven.

Samenvatting

Het ontwikkelen van WordPress-plug-ins betekent dat je je eigen ideeën integreert in een grote en uitgebreide ecosystem. De kern van dit proces is het begrijpen en gebruiken van action- en filter-hooks. Een succesvol ontwikkelingsproces begint met een duidelijke, modulaire bestandsstructuur, die een solide basis vormt voor het later onderhouden en uitbreiden van het plug-in. Door achtergrondinstellingen te creeren, kan het plug-in gebruiksvriendelijk en gemakkelijk te configureren worden; functionaliteiten kunnen bovendien naadloos worden geïntegreerd in het front-end van de website met behulp van shortcodes, widgets of aangepaste API's. Beveiliging, internationale compatibiliteit en de kwaliteit van het code zijn belangrijke aspecten die gedurende het hele ontwikkelingsproces moeten worden beschermd. Het naleven van de WordPress-编码standaarden en -best practices zorgt niet alleen voor een stabiele werking van het plug-in, maar ook voor een betere integratie in het ecosystem, waardoor het meer gebruikers kan ondersteunen.

Veelgestelde vragen (FAQ)

Welke PHP-kennis is vereist om een WordPress-plugin te ontwikkelen?

Voor het ontwikkelen van een simpel plugin zijn enkele basiskennis van PHP nodig, zoals het gebruik van variabelen, functies, conditionele statements en cycli. Echter, om een complexe, veilige en efficiënte commerciële plugin te ontwikkelen, is een dieper inzicht vereist, waaronder kennis van objectgericht programmeren (OOP) en de kern-API's van WordPress (bijvoorbeeld klassen voor het bewerken van databases). wpdbHTTP-requests, API's, en dergelijke; beste beveiligingspraktijken (zoals datavalidatie, encoding, bescherming tegen SQL-injecties en CSRF-aanvallen); en enkele basiskennis van JavaScript en CSS voor front-end-interactie.

Het is verstandig om te beginnen met het aanpassen van bestaande kleine plugins of het bouwen van simpele functies, en daarna steeds verder te leren.

Hoe kan ik zorgen dat de plugin die ik ontwikkeld heb veilig is?

Het garanderen van de veiligheid van plugins is een proces dat op meerdere niveaus plaatsvindt. Allereerst is het belangrijk om alle invoer van gebruikers of externe bronnen (zoals formuliergegevens, URL-parameters en cookies) streng te verifiëren en te reinigen. Hierbij kunnen functies van WordPress worden gebruikt, zoals… sanitize_text_field(), esc_html(), esc_url() 和 wp_kses() etc.

Ten tweede: wanneer je met de database werkt, moet je altijd gebruikmaken van… $wpdb De door de klasse geboden methoden (zoals) prepare() Om SQL-injecties te voorkomen, moet ervoor worden gezorgd dat bepaalde codefragmenten (‘statements’) op veilige manier worden verwerkt. Voordat enige gegevens naar de front-end worden gestuurd, moet deze gegevens worden geëscapeseerd. Voor operaties die betrekking hebben op bevoegingen, moet altijd gebruik worden gemaakt van beveiligingsfuncties zoals verificatie van gebruikersrechten. current_user_can()Daarnaast wordt een niet-ce (nonce)-waarde gebruikt om de intentie van de verzoek te verifiëren, waardoor het voorkomen van cross-site request forgery (CSRF) wordt geboden.

Nadat de plugin is ontwikkeld, hoe worden deze vervolgens verspreid en updatet?

Er zijn twee principale manieren om plugins te distribueren: via het officiële WordPress-plugincatalogus of door ze rechtstreeks beschikbaar te stellen op je eigen website voor download. Als je wilt dat plugins door gebruikers in hun backend met één klik kunnen worden geïnstalleerd en automatisch worden bijgewerkt, moet je de plugin indienen in het officiële catalogus. Hiervoor moet de plugincode voldoen aan de GPLv2-licentie (of een hogere versie) en moet de plugin worden getest op veiligheid en codekwaliteit.

Na het indienen van je plugin, zal WordPress de code van je plugin lezen uit zijn officiële Subversion (SVN) repository. Je moet de “Version”-nummer in de commentaren van het hoofdbestand in het SVN-repository updaten en een nieuwe tag met deze versiennummer indienen, om een update-notificatie te triggeren.

Voor commerciële plugins wordt meestal een update-service opgezet op eigen servers. Dit houdt in dat er een update-checker moet worden geschreven, die gebruikmaakt van hooks (bijvoorbeeld…) pre_set_site_transient_update_pluginsIntegreert met het update-systeem van WordPress, vergelijkt de versiegegevens op de remote server en biedt updatepakketten aan.

Hoe voorkom je dat de namen van klassen en functies in een plugin niet in conflict komen met andere plugins?

Het voorkomen van namenconflicten is een fundamentele vereiste bij het ontwikkelen van professionele plugins. De beste praktijk is het gebruik van prefixen. Gebruik voor alle klassen, functies, constanten en zelfs globale variabelen (probeer dit zoveel mogelijk te vermijden) een unieke en beschrijvende prefix. Deze prefix kan meestal een afkorting of de volledige naam van je bedrijf of de plugin zijn.

Als je plugin bijvoorbeeld de naam “Awesome Gallery” heeft, kan je prefix voor de functies zijn: ag_ 或 awesome_gallery_De klassenaam kan zijn… AG_Core 或 Awesome_Gallery_Admin。

Een betere manier is om de code op te pakken in een klasse, zodat de meeste functies als methoden van de klasse worden opgeroepen. $this->method()Dit voorkomt dat de globale namenspace wordt ‘vervuikt’. Voor functies die wel in de globale namenspace moeten worden gedefinieerd, moet altijd een lang en uniek prefix worden gebruikt.