De ultieme gids voor het ontwikkelen van WordPress-plug-ins: van nul tot één, met kerntechnieken voor het bouwen van aangepaste functionaliteiten.

Het begrijpen van de basisarchitectuur van WordPress plugins

Voordat je begint met schrijven van code, is het van belang om de basis van een WordPress-plugin te begrijpen. Een plugin bestaat in feite uit één of meerdere PHP-bestanden, die zich bevinden in een specifieke map in het WordPress-installatiepad./wp-content/plugins/In de map kunnen de kernfuncties van WordPress worden uitgebreid met behulp van de API (Application Programming Interface) die WordPress biedt. Het hart van een plugin is een hoofdbestand, dit bestand moet bepaalde commentaren in de bestandskop bevatten, zodat WordPress het kan herkennen en beheren.

De samenstelling van het hoofdbestand van een plugin

De entrypunt van een plugin is meestal een PHP-bestand met dezelfde naam als de plugin. De kop van dit bestand moet een standaardiserde commentaar bevatten, waarmee WordPress meta-informatie wordt verstrekt. Deze commentaar moet ten minste de naam van de plugin, een beschrijving, de versie, de ontwikkelaar en de licentie bevatten. Als bijvoorbeeld een plugin heet “My Custom Widget”, moet het hoofdbestand van de plugin de volgende inhoud hebben:my-custom-widget.phpDe opening van... kan er als volgt uitzien:

<?php
/**
 * Plugin Name: My Custom Widget
 * Plugin URI: https://www.example.com/my-custom-widget
 * Description: 这是一个用于演示的自定义小工具插件。
 * Version: 1.0.0
 * Author: Your Name
 * Author URI: https://www.example.com
 * License: GPL v2 or later
 * Text Domain: my-custom-widget
 */

In deze commentaar wordt aangegeven dat “Plugin Name” het enige vereiste veld is voor het herkennen van een plugin door WordPress. Hoewel de overige velden optioneel zijn, is het aan te raden ze allemaal in te vullen voor meer standaardisatie en onderhoudsgemak van de plugin. Het veld “Text Domain” is belangrijk voor internationalisatie en is essentieel om later meerdere talenondersteuning voor de plugin te kunnen toevoegen.

Aanbevolen leesmateriaal Ontwikkelingshandleiding voor WordPress-plug-ins: maak je eigen aangepaste functionaliteitsmodules vanaf nul.。

Beste praktijken voor de structuur van de plugin-map

Voor eenvoudige plugins is één PHP-bestand vaak voldoende. Voor complexere plugins is echter een duidelijke, modulaire directorystructuur onmisbaar. Een typisch professioneel plugin-verzeichnis bevat meestal de volgende onderdelen:

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

• Main fileplugin-name.phpDe guidefile voor het plugin bevat commentaren in de bestandskop en de kernlogica of de loader.
• includes/ 或 src/De map 'catalog' wordt gebruikt om de belangrijkste PHP-klassen en functionaliteiten op te slaan.
• admin/De map bevat alleen code en pagina's die te maken hebben met de backend-beheerinterface.
• public/ 或 frontend/De inhoudslijst bevat de logica die wordt gebruikt voor het weergeven van de front-end van de website.
• assets/De inhoudslijst bevat statische bronnen zoals JavaScript, CSS en afbeeldingen.
• languages/Verzeichnis: hier worden de internationale vertaalmappen (bestanden met de extensies .po en .mo) opgeslagen.
• uninstall.phpEen optioneel, maar aan te raden bestand dat wordt gebruikt om gegevens te schoonmaken, zoals instellingen uit de database, wanneer de gebruiker een plugin verwijdert.

Deze gestructureerde manier van organiseren maakt de code niet alleen gemakkelijk te onderhouden en te bewerken in teamverband, maar voldoet ook aan de beste praktijken van moderne PHP-programmering.

Voor het beheersen van kernontwikkelingshulpmiddelen zijn het belangrijk om de mogelijkheden van acties (actions) en filterhaken (filter hooks) te begrijpen en te kunnen gebruiken.

De kernfilosofie van WordPress-pluginontwikkeling is “hooks”. Het hook-systeem biedt je de mogelijkheid om je plugin op bepaalde momenten in de kernprocessen van WordPress te “in te hangen”, waardoor je functies kunt wijzigen of toevoegen zonder de kerncode rechtstreeks te hoeven aanpassen. Er bestaan twee soorten hooks: action hooks en filter hooks.

Het gebruik van action hooks

Action hooks worden gebruikt om je eigen code uit te voeren wanneer een bepaald evenement plaatsvindt. Denk hierbij aan het publiceren van een artikel of het initialiseren van het menu in de beheeromgeving.add_action()Een functie kan worden “gemonteerd” (of 'gekoppeld') aan een actie-hook.

Stel dat je wilt dat er automatisch een copyright-verklaring wordt toegevoegd aan het eind van elke artikel. Hiervoor kun je gebruikmaken van…the_contentDeze filter (let op: dit is in feite een filter, maar de werking is vergelijkbaar met die van een actie) wordt gebruikt om bijvoorbeeld logs te bewaren nadat een gebruiker is ingelogd. Hieronder staat een voorbeeld van het gebruik van actie-haken (action hooks).wp_footerEen voorbeeld van hoe informatie in de voetnoot van een website wordt weergegeven:

Aanbevolen leesmateriaal WordPress-pluginontwikkeling beheersen: van nul tot een zelfgemaakte functie bouwen。

function myplugin_add_footer_text() {
    echo '<p style="text-align:center;">Fijn dat je deze site gebruikt!</p>';
}
add_action( 'wp_footer', 'myplugin_add_footer_text' );

Als WordPress dit punt bereikt…wp_footerWanneer je op deze actiepunt klikt (meestal in het thema)...footer.phpCall in the middlewp_footer()Als de function (de genoemde 'functie') wordt opgeroepen, worden alle functies die erop zijn gemonteerd geactiveerd, inclusief de functie die we net hebben gedefinieerd.myplugin_add_footer_text。

Het gebruik van filterhooks

Filter hooks worden gebruikt om gegevens te bewerken. Ze nemen een variabele op, verwerken deze in je functie en moeten de gewijzigde variabele teruggeven. Dit is een van de krachtigste manieren om de standaardwerking van WordPress te veranderen.add_filter()De functie wordt gemonteerd.

Als je bijvoorbeeld de lengte van de samenvatting van een artikel wilt veranderen, kun je dit doen met...excerpt_lengthFilter:

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

function myplugin_custom_excerpt_length( $length ) {
    // 将默认的55个单词改为20个单词
    return 20;
}
add_filter( 'excerpt_length', 'myplugin_custom_excerpt_length' );

Een andere veel voorkomende toepassing is het aanpassen van de weergave van artikelinhoud. De onderstaande code voegt een waarschuwingsscherm toe aan de begin van alle artikelinhoud:

function myplugin_add_content_notice( $content ) {
    if ( is_single() ) {
        $notice = '<div class="notice">Deze tekst is origineel materiaal. Vraag om toestemming om het te reproduceren en verwees naar de bron.</div>';
        $content = $notice . $content;
    }
    return $content;
}
add_filter( 'the_content', 'myplugin_add_content_notice' );

Het begrijpen en vaardig gebruiken van verschillende 'hooks' is essentieel om een efficiënte WordPress-developer te worden. Het officiële WordPress-pluginhandboek bevat een volledige lijst met alle beschikbare hooks.

Constructeer een backend-beheerinterface voor plugins.

De meeste plugins hebben een configuratiepagina nodig, zodat de webbeheerder opties kan instellen. WordPress biedt een uitgebreide API aan om aantrekkelijke en standaardiseerde beheerpagina's in het achtergrondscherm te creeren.

Aanbevolen leesmateriaal Het ontwikkelen van WordPress-plug-ins: van nul tot één, waarbij je je eerste uitbreidingsmodule maakt.。

Een top-level beheermenu en -pagina maken

Gebruikadd_menu_page()Deze functie kan een toppenmenu-item toevoegen aan de achtergrondssidebarm van je plugin, samen met de corresponderende instellingenpagina. Voor het gebruik van deze functie moet je parameters definiëren, zoals de titel van de pagina, de titel van het menu, de vereiste toegangrechten, een alias voor het menu en een callback-functie.

Het volgende codevoorbeeld maakt een hoofdmenupagina met de naam “Mijn plugininstellingen”:

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

function myplugin_add_admin_menu() {
    add_menu_page(
        '我的插件设置',          // 页面标题
        '我的插件',             // 菜单标题
        'manage_options',       // 权限（通常为manage_options，仅管理员可见）
        'myplugin-settings',    // 菜单别名（slug），用于URL
        'myplugin_settings_page_html', // 用于渲染页面内容的回调函数
        'dashicons-admin-generic', // 菜单图标（使用Dashicons）
        80                     // 菜单位置
    );
}
add_action( 'admin_menu', 'myplugin_add_admin_menu' );

// 定义渲染页面内容的回调函数
function myplugin_settings_page_html() {
    // 检查用户权限
    if ( ! current_user_can( 'manage_options' ) ) {
        return;
    }
    ?>
    <div class="wrap">
        <h1><?php echo esc_html( get_admin_page_title() ); ?></h1>
        <form action="/nl/options.php/" method="post" data-trp-original-action="options.php">
            <?php
            // 输出设置字段、非ces等（需要与settings API配合使用）
            settings_fields( 'myplugin_options' );
            do_settings_sections( 'myplugin-settings' );
            submit_button( '保存设置' );
            ?>
        <input type="hidden" name="trp-form-language" value="nl"/></form>
    </div>
    &lt;?php
}

De opties worden veilig verwerkt met behulp van de API-instellingen.

Het direct indienen van gegevens via een formulier brengt beveiligingsrisico's met zich mee. De WordPress Settings API biedt een veilige en standaardiseerde manier om instellingen op te slaan, te verifiëren en te bewerken. De API verzorgt automatisch de verificatie van nonces, het controleren van toegangsrechten en het schoonmaken van de gegevens.

Het gebruiken van de Settings API omvat meestal drie stappen:
1. Registreeringsinstellingen: gebruikenregister_setting()Een groep opties definiëren met hun corresponderende validatie-callbacks.
2. Voeg een instellingenblok toe: gebruikadd_settings_section()Voeg een blok toe aan de pagina.
3. 添加设置字段：使用add_settings_field()Voeg specifieke invoervelden toe binnen de blok.

Hieronder staat een versimpeld voorbeeld dat laat zien hoe je een veld voor tekstopties kunt registreren:

function myplugin_settings_init() {
    // 1. 注册一个设置选项组
    register_setting( 'myplugin_options', 'myplugin_options_field', array(
        'sanitize_callback' => 'myplugin_sanitize_text_field' // 清理函数
    ) );

// 2. 添加一个设置区块
    add_settings_section(
        'myplugin_section_main',
        '主要设置',
        null, // 可选的区块描述回调函数
        'myplugin-settings'
    );

// 3. 为区块添加一个字段
    add_settings_field(
        'myplugin_field_text',
        '示例文本',
        'myplugin_field_text_html', // 渲染字段HTML的回调函数
        'myplugin-settings',
        'myplugin_section_main',
        array( 'label_for' => 'myplugin_field_text' )
    );
}
add_action( 'admin_init', 'myplugin_settings_init' );

// 字段渲染函数
function myplugin_field_text_html() {
    $options = get_option( 'myplugin_options_field' );
    $value = isset( $options['text'] ) ? $options['text'] : '';
    ?>
    <input type="text" id="myplugin_field_text" name="myplugin_options_field[text]" value="<?php echo esc_attr( $value ); ?>" class="regular-text">
    <?php
}

// 数据清理函数
function myplugin_sanitize_text_field( $input ) {
    $sanitized_input = array();
    if ( isset( $input['text'] ) ) {
        $sanitized_input['text'] = sanitize_text_field( $input['text'] );
    }
    return $sanitized_input;
}

Realisatie van de front-end-functionaliteiten van de plugin en de kortere code

Plugins zijn niet alleen bedoeld voor de backend, maar nog belangrijker: ze bieden functionaliteiten voor de frontend van een website. Naast het eerder genoemde mogelijkheid om content te bewerken met behulp van hooks, zijn shortcodes een krachtig hulpmiddel om dynamische functionaliteiten te bieden aan contenteditors en templatebestanden.

Snelcodes maken en gebruiken

Shortcodes bieden gebruikers de mogelijkheid om met één simpel tag te werken (bijvoorbeeld…)[my_gallery]In artikelen of pagina's complexe functies kunnen worden ingebouwd. Hierdoor kunnen gebruikers extra mogelijkheden verkrijgen.add_shortcode()Een functie om een kort code-teken te registreren.

De onderstaande code maakt een simpel stuk kort programma dat een knop met een aangepaste groet weergeeft:

function myplugin_hello_shortcode( $atts, $content = null ) {
    // 解析短代码属性，并提供默认值
    $attributes = shortcode_atts(
        array(
            'name' => '访客',
            'color' => 'blue',
        ),
        $atts,
        'hello' // 短代码标签
    );

// 确保颜色值安全
    $color = esc_attr( $attributes['color'] );
    $name = esc_html( $attributes['name'] );

// 构建输出
    $output = '<button style="background-color: ' . $color . '; padding: 10px; color: white; border: none;">';
    $output .= '你好，' . $name . '！';
    $output .= '</button>';

// 如果短代码是封闭式的（有内容），则包含内容
    if ( ! is_null( $content ) ) {
        $output .= '<div>'`. do_shortcode($content)`.'</div>';
    }

return $output;
}
add_shortcode( 'hello', 'myplugin_hello_shortcode' );

Gebruikers kunnen dit in de artikeleditor op de volgende manier gebruiken:
* [hello name="张三" color="red"]
* [hello]点击我！[/hello]

Een custom-tweak toevoegen aan een plugin

Widgets zijn inhoudsblokken die zich bevinden in de sidebar of voetnoot van WordPress. Om een custom widget-class te maken, is het nodig om de bestaande code te uitbreiden.WP_WidgetDe basisklasse bevat enkele belangrijke methoden die zijn geimplementeerd: de constructor, de methode voor het weergeven van gegevens op de frontend en de methode voor het updaten van formulieren.

Maak een simpel hulpmiddel dat de titels van de recentste artikelen weergeeft:

class Myplugin_Recent_Posts_Widget extends WP_Widget {
    // 构造方法：定义小工具ID、名称和描述
    public function __construct() {
        parent::__construct(
            'myplugin_recent_posts',
            '我的插件：近期文章',
            array( 'description' => '显示您网站的最新文章列表。' )
        );
    }

// 前端显示逻辑
    public function widget( $args, $instance ) {
        echo $args['before_widget'];
        if ( ! empty( $instance['title'] ) ) {
            echo $args['before_title'] . apply_filters( 'widget_title', $instance['title'] ) . $args['after_title'];
        }

$posts = get_posts( array( 'numberposts' => $instance['number'] ?: 5 ) );
        echo '<ul>';
        foreach ( $posts as $post ) {
            setup_postdata( $post );
            echo '<li><a href="/nl/' . get_permalink( $post->ID ) . '/">' . get_the_title( $post-&gt;ID ) . '</a></li>';
        }
        wp_reset_postdata();
        echo '</ul>';

echo $args['after_widget'];
    }

// 后台小工具表单
    public function form( $instance ) {
        $title = ! empty( $instance['title'] ) ? $instance['title'] : '近期文章';
        $number = ! empty( $instance['number'] ) ? $instance['number'] : 5;
        ?&gt;
        <p>
            <label for="<?php echo esc_attr( $this->get_field_id( 'title' ) ); ?>">Titel:</label>
            <input class="widefat" id="<?php echo esc_attr( $this->get_field_id( 'title' ) ); ?>" name="<?php echo esc_attr( $this->get_field_name( 'title' ) ); ?>" type="text" value="<?php echo esc_attr( $title ); ?>">
        </p>
        <p>
            <label for="<?php echo esc_attr( $this->get_field_id( 'number' ) ); ?>">Aantal artikelen weergeven:</label>
            <input id="<?php echo esc_attr( $this->get_field_id( 'number' ) ); ?>" name="<?php echo esc_attr( $this->get_field_name( 'number' ) ); ?>" type="number" min="1" value="<?php echo esc_attr( $number ); ?>">
        </p>
        &lt;?php
    }

// 更新小工具设置
    public function update( $new_instance, $old_instance ) {
        $instance = array();
        $instance[&#039;title&#039;] = ( ! empty( $new_instance[&#039;title&#039;] ) ) ? sanitize_text_field( $new_instance[&#039;title&#039;] ) : &#039;&#039;;
        $instance[&#039;number&#039;] = ( ! empty( $new_instance[&#039;number&#039;] ) ) ? absint( $new_instance[&#039;number&#039;] ) : 5;
        return $instance;
    }
}

// 注册这个小工具
function myplugin_register_widget() {
    register_widget( &#039;Myplugin_Recent_Posts_Widget&#039; );
}
add_action( &#039;widgets_init&#039;, &#039;myplugin_register_widget&#039; );

Samenvatting

Het ontwikkelen van WordPress-plug-ins vereist een combinatie van PHP-programmering en een diepere kennis van de kernarchitectuur van WordPress. Een goede start is het opstellen van een georganiseerde bestandsstructuur en een juiste hoofdbestand. Vervolgens is het belangrijk om de action hooks en filter hooks goed te beheersen, aangezien deze je de mogelijkheid geven om je code op precieze momenten in te voegen of de datastroom te bewerken. Voor een gebruikersvriendelijke configuratie is het essentieel om de Admin Menu API en Settings API van WordPress te gebruiken om een veilig en standaardiserd beheerinterfacing te bouwen. Ten slotte kun je de functionaliteiten van je plugin naadloos integreren in het front-end-content en de lay-out van de website met het gebruik van shortcodes en aangepaste widgets, waardoor gebruikers flexibele manieren van contentweergave krijgen. Door deze kerntechnieken te volgen, kun je effectieve, goed georganiseerde en gemakkelijk te onderhouden WordPress-plug-ins bouwen.

Veelgestelde vragen (FAQ)

Welke voorwaarden zijn vereist om een WordPress-plugin te ontwikkelen?

Je moet een solide basis in PHP-programmering hebben en een begrip van HTML, CSS en JavaScript. Het is handig om kennis te hebben van de concepten van objectgerichte programmering (OOP), aangezien dit zeer nuttig is bij het ontwikkelen van grotere plugins. Daarnaast zijn een lokale ontwikkelomgeving (zoals Local by Flywheel, XAMPP of MAMP) en een IDE (zoals VS Code of PhpStorm) essentiële hulpmiddelen voor het bewerken van code.

Hoe kan ik zorgen dat de plugins die ik ontwikkel veilig en high-performance zijn?

Wat betreft de veiligheid: verifieer en reinig altijd de invoer van de gebruiker, en gebruik de ingebouwde functies van WordPress.sanitize_text_field(), esc_html(), wp_kses()Wanneer je formulieren en Ajax-verzoeken verwerkt, moet je altijd gebruikmaken van nonce-verificatie. Gebruik de vooraf gedefinieerde WordPress-databasemethoden (bijvoorbeeld…)$wpdbOm SQL-injecties te voorkomen: Laad scripts en stijlen alleen op wanneer dit nodig is (door gebruik van…). Wat betreft de prestaties: De scripts en stijlen worden alleen op het moment dat ze vereist zijn geladen, waardoor de performance wordt beschermd.wp_enqueue_script()Zorg ervoor dat afhankelijkheden en laadcondities op een verstandige manier worden ingesteld. Verstopt de tijdrovende resultaten van queries in de cache met behulp van de Transients API. Voorkom dat er te veel onnodige database-verzoeken worden uitgevoerd tijdens het initialiseren van de plugin.

Hoe moet ik mijn plugin debuggen en testen?

Tijdens de ontwikkelingsfase, moet u...wp-config.phpDe optie 'In de file activeren' is geactiveerd.WP_DEBUG和WP_DEBUG_LOGDit zal PHP-fouten en waarschuwingen opslaan in een logbestand, waardoor het gemakkelijker wordt om problemen op te sporen. Gebruik de ontwikkelaarstool van de browser om netwerkverzoeken en JavaScript-fouten te bekijken. Voor het oplossen van logische problemen in het code is dit zeer handig.error_log()Functies en plugins zoals “Query Monitor” zijn uitstekende hulpmiddelen. Zorg ervoor dat ze worden getest op verschillende versies van PHP en WordPress om de compatibiliteit te controleren.

Hoe voeg ik internationaal ondersteuningsmogelijkheden toe aan mijn plugin?

Allereerst moet de instelling in de commentaren bovenin het hoofdbestand correct worden gedaan.Text Domain(Voorbeeld: my-plugin-text-domain). In het code, moet alle tekststrings die worden vertaald worden gemarkeerd met...__()Of_e()Maak een function wrapper en stuur je tekstgebied daarin door. Vervolgens gebruik je een tool als Poedit om de tekst te bewerken..potTemplatebestanden, waarna er verschillende talen worden gecreëerd op basis van deze templates..po和.moVertaal het bestand en plaats het in het plugin./languages/Inhoudsopgave.

Nadat mijn plugin is ontwikkeld, hoe kan ik deze publiceren?

Je kunt je plugin publiceren in de officiële WordPress-plugincatalogus; dit is de meest brede manier om je plugin te distribueren. Hiervoor moet je plugin voldoen aan de GPL-licentie en worden onderworpen aan een strenge codebeoordeling. Je kunt je plugin ook zelf op je website of op een derde-partijsmarkt distribueren. Ongeacht welke methode je kiest, is het belangrijk om duidelijke documentatie, update-logboeken en informatie over compatibiliteit te bieden, en om een plan op te stellen voor het voortdurende onderhoud en bijwerken van je plugin.