Débuter de zéro : Préparation et mise en place de l'environnement
Avant de commencer à écrire votre premier plugin, il est essentiel de préparer correctement le terrain. Cela inclut de comprendre la structure de base des plugins WordPress, de mettre en place un environnement de développement local sécurisé, et de saisir la philosophie fondamentale du développement de plugins.
Un plugin typique de WordPress est un fichier qui se trouve dans le répertoire des plugins de votre site web. /wp-content/plugins/ Il s’agit d’un dossier indépendant situé dans le répertoire principal. Son cœur est un fichier PHP principal qui contient un en-tête spécifique. Ce fichier principal ne contient pas seulement les métadonnées du plugin, mais il sert également de point d’entrée pour toutes les fonctionnalités de celui-ci. Il existe deux façons de lancer le plugin : l’une consiste à utiliser une combinaison de fonctions orientées procédure, et l’autre à recourir à une structure de classes orientées objet. Cette dernière méthode est plus préférée dans le développement de plugins modernes en raison de son meilleur niveau d’encapsulation et de son organisation du code.
Un environnement de développement local est essentiel pour un développement efficace. Il est recommandé d’utiliser des outils tels que XAMPP, Local by Flywheel ou Docker pour mettre en place un environnement de fonctionnement intégrant Apache/Nginx, MySQL et PHP. Cela vous permet de effectuer des tests et des débogages en toute liberté sans affecter le site web en ligne.
Lectures recommandées Partir de zéro : Guide complet du développement d’un plugin WordPress et partage des meilleures pratiques.。
Construire la structure d'un plugin : architecture et fichiers essentiels
Cette section expliquera en détail comment créer, à partir de zéro, une structure de base pour un plugin conforme aux normes de WordPress. Une bonne structure de base est la clé pour que le plugin soit stable, sécurisé et facile à maintenir.
Créer les fichiers de plugins principaux nécessaires.
La vie d’un plugin commence par un fichier principal. Le nom de ce fichier est généralement le même que le nom du dossier contenant votre plugin. Par exemple, si le dossier de votre plugin s’appelle… my-custom-pluginAlors, le fichier principal peut être nommé… my-custom-plugin.phpEn haut de ce fichier, vous devez utiliser un bloc de commentaires conforme à un format spécifique pour déclarer les informations du plugin. Cela est essentiel pour que WordPress puisse reconnaître le plugin et l'afficher dans la liste de gestion de l'administration.
Voici un exemple de en-tête de fichier de plugin le plus basique :
<?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
*/Dans cette note, l’entrée “ Plugin Name ” est obligatoire, tandis que les autres champs sont facultatifs mais sont fortement conseillés. Les champs “ Text Domain ” et “ Domain Path ” sont utilisés pour l’internationalisation (i18n) du plugin, afin de préparer sa traduction dans plusieurs langues.
Fichiers et dossiers contenant les plugins de l'organisation
Avec l’augmentation du nombre de fonctionnalités des plugins, il n’est pas conseillé de concentrer tout le code dans le fichier principal. Une structure de plugins bien organisée comprend généralement plusieurs sous-dossiers et fichiers. Une structure courante est la suivante :
Lectures recommandées Guide complet pour le développement de plugins WordPress : Un tutoriel pratique de A à Z pour les débutants jusqu'à la publication en ligne。
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 # 插件卸载清理脚本Dans my-custom-plugin.php Dans le fichier principal, nous n’écrivons généralement pas directement la logique métier, mais le considérons plutôt comme un “ lanceur ” (un programme chargé de démarrer l’application). Ce fichier contient les fichiers nécessaires et initialise les classes essentielles de l’application.
// 防止直接文件访问
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' );Liens vers les fonctionnalités de base de WordPress : les hooks d’actions et de filtres
Le système de plugins de WordPress est si puissant parce qu’il offre un grand nombre de points d’interaction (“ événements ”), permettant aux développeurs de modifier ou d’améliorer le fonctionnement du site sans avoir à modifier le code de base. Ces mécanismes sont appelés « hooks » et se divisent principalement en deux catégories : les actions (Actions) et les filtres (Filters). Ils constituent le pont entre les plugins et le noyau de WordPress.
Comprendre et utiliser les « action hooks »
Les « action hooks » vous permettent d’exécuter du code personnalisé lorsque un événement spécifique se produit. Par exemple, lorsque un article est publié, lorsque un utilisateur se connecte, ou lorsque une page du panneau de gestion est chargée. add_action() Les fonctions peuvent permettre d“”installer” (ou de “charger”) votre propre fonction sur ces points d’ancrage (ou “hooks”).
Si vous souhaitez ajouter automatiquement une déclaration de droits d’auteur en bas de l’article, vous pouvez utiliser des outils ou des scripts appropriés. the_content Ce « hook d’action » (en réalité, il s’agit d’un filtre, mais son utilisation est similaire à celle d’une action ; c’est un exemple classique utilisé pour illustrer ce concept) est plus approprié pour envoyer un e-mail de bienvenue à l’utilisateur après son enregistrement réussi.
// 这是一个动作钩子的使用示例
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' );Maîtriser la manière d'utiliser les filtres
Les hooks de filtre vous permettent de modifier les données. Lorsque WordPress exécute un processus, il transmet des données spécifiques à travers une série de filtres. Votre plugin peut intercepter ces données, les modifier, puis les renvoyer. add_filter() Cela peut être réalisé à l'aide de fonctions.
L’exemple le plus courant concerne la modification du contenu affiché dans les articles. Par exemple, ajouter automatiquement une image représentative en tête de chaque article en tant qu’image de présentation.
Lectures recommandées Guide de début pour le développement de plugins WordPress : Construire votre premier module de fonctionnalité personnalisé à partir de zéro。
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' );Réaliser la fonctionnalité d'un plugin : intégrer l'administration (back-end) avec l'interface utilisateur (front-end).
Un plugin complet doit généralement interagir avec l’utilisateur, ce qui signifie que vous devez créer une interface de gestion pour gérer les paramètres, et il peut également être nécessaire d’ajouter de nouvelles fonctionnalités ou du contenu sur les pages frontales.
Créer la page des paramètres du back-office
Fournir une page de configuration en arrière-plan claire pour un plugin est essentiel pour une bonne expérience utilisateur. WordPress propose plusieurs API pour ajouter des menus principaux ou des sous-menus. Ce processus implique généralement deux étapes : enregistrer les éléments du menu et définir les fonctions de rappel (callback) correspondantes afin de générer le contenu de la page.
Voici un exemple de l'ajout d'un élément de menu secondaire sous le menu principal “ Paramètres ” :
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>Les paramètres de mon plugin</h1>
<form action="/fr/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="fr"/></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 ) . '" />';
}
}Afficher les fonctionnalités sur la partie frontale du site web.
Les méthodes pour mettre en œuvre les fonctionnalités frontales sont diverses : il peut s’agir de codes courts (shortcodes), de petits outils (widgets), ou de modifications apportées à l’affichage existant via des API. Les codes courts constituent une approche simple et efficace qui permet aux utilisateurs d’activer des fonctionnalités d’extensions en saisissant simplement une étiquette dans l’éditeur d’articles ou de pages.
Pour créer des codes courts, il est nécessaire d’utiliser… add_shortcode() Fonction :
// 定义一个简单的短代码，用于显示一个问候语
function my_plugin_greeting_shortcode( $atts ) {
// 解析短代码属性
$atts = shortcode_atts( array(
'name' => '访客',
), $atts, 'greeting' );
// 返回输出内容
return '<p class="my-plugin-greeting">Bonjour, '. esc_html($atts['name'])'. ‘!</p>'php
add_shortcode('greeting', 'my_plugin_greeting_shortcode');Les utilisateurs n’ont qu’à saisir leur texte dans l’éditeur d’articles. [greeting name="张三"]Dans ce cas, la partie frontale de l’application affichera le paragraphe “ Bonjour, Zhang San ! ”.
résumés
Le développement de plugins pour WordPress consiste à intégrer des idées personnalisées dans un vaste écosystème, en utilisant des concepts clés tels que les actions (actions) et les hooks de filtre (filter hooks). Un développement réussi commence par une structure de fichiers claire et modulaire, ce qui pose les bases solides pour les mises à jour et les extensions ultérieures. En créant des pages de configuration en back-end, les plugins deviennent plus faciles à utiliser et à configurer pour les utilisateurs. De plus, des fonctionnalités peuvent être intégrées de manière transparente à l’interface utilisateur du site à l’aide de codes courts (shortcodes), de gadgets ou d’APIs personnalisées. La sécurité, la compatibilité avec les langues internationales et la qualité du code sont des éléments essentiels à prendre en compte tout au long du processus de développement. Respecter les normes de codage et les meilleures pratiques de WordPress permet non seulement d’assurer le fonctionnement stable des plugins, mais aussi de les intégrer plus efficacement à l’écosystème, offrant ainsi de meilleurs services à un plus grand nombre d’utilisateurs.
FAQ Foire aux questions
Quel niveau de connaissances en PHP est nécessaire pour développer des plugins pour WordPress ?
Pour développer un simple plugin, il suffit de connaître les bases du PHP : les variables, les fonctions, les instructions conditionnelles et les boucles. Cependant, pour créer des plugins de niveau commercial qui soient fonctionnels, sûrs et efficaces, il est nécessaire de disposer d’une compréhension plus approfondie des concepts de programmation orientée objet (POO) ainsi que des API du noyau de WordPress (notamment celles relatives aux opérations sur la base de données). wpdbLes connaissances nécessaires incluent les API de requêtes HTTP, ainsi que les meilleures pratiques en matière de sécurité (comme la validation des données, l’encodage des données, la prévention des injections SQL et des attaques CSRF). De plus, une base en JavaScript et en CSS est requise pour les interactions utilisateur au niveau du front-end.
Il est conseillé de commencer par modifier les petits plugins existants ou en créer de nouveaux avec des fonctionnalités simples, puis d’approfondir progressivement vos connaissances.
Comment m'assurer que le plug-in que j'ai développé est sécurisé ?
Assurer la sécurité des plugins est une tâche qui implique plusieurs étapes. Tout d’abord, il est essentiel de vérifier et de nettoyer strictement toutes les données provenant des utilisateurs ou de l’extérieur (telles que les données des formulaires, les paramètres URL, les cookies). Pour ce faire, il est possible d’utiliser les fonctions fournies par WordPress. sanitize_text_field(), esc_html(), esc_url() et wp_kses() etc.
Deuxièmement, lors des opérations sur la base de données, il est essentiel d’utiliser… $wpdb Les méthodes fournies par la classe (comme…) prepare() Les injections SQL peuvent être évitées en utilisant des mécanismes de validation des données (comme les expressions régulières) pour vérifier que les entrées reçues correspondent aux attentes. Avant de transmettre tout type de données à l’interface utilisateur, il est essentiel d’effectuer des échappements appropriés. Pour les opérations qui impliquent des droits d’accès, il faut toujours utiliser des fonctions de vérification des autorisations pour s’assurer que l’utilisateur dispose des droits requis. current_user_can()De plus, l’utilisation d’un élément non CE (nonce) permet de vérifier l’intention de la demande, afin de prévenir le détournement de requêtes entre sites (CSRF – Cross-Site Request Forgery).
Une fois le développement d’un plugin terminé, comment le distribuer et le mettre à jour ?
Il existe principalement deux méthodes de distribution des plugins : soit via le catalogue officiel des plugins WordPress, soit en les mettant directement à disposition pour téléchargement sur son propre site web. Si l’on souhaite que les plugins soient installés en un clic depuis l’administration de l’utilisateur et que des mises à jour soient automatiquement effectuées, il est nécessaire de les soumettre au catalogue officiel. Cela implique que le code du plugin respecte la licence GPLv2 (ou une version ultérieure) et qu’il passe par des vérifications strictes en matière de sécurité et de qualité du code.
Après l’envoi de votre contribution, WordPress récupérera le code de votre plugin depuis son répertoire officiel Subversion (SVN). Vous devez mettre à jour le numéro de version indiqué dans les commentaires en tête du fichier principal du répertoire SVN, puis soumettre une nouvelle étiquette (Tag) contenant ce nouveau numéro de version afin de déclencher une notification d’actualisation.
Pour les plugins commerciaux, il est habituel de mettre en place un service d’actualisation sur son propre serveur. Cela implique la rédaction d’un vérificateur d’actualisations, qui utilise des mécanismes d’interfaçage (des « hooks ») pour… pre_set_site_transient_update_pluginsIntégration avec le système d’actualisation de WordPress : comparaison des informations de version sur les serveurs distants et fourniture des paquets d’actualisation.
Comment éviter les conflits entre les noms de classes et de fonctions présents dans les plugins ?
Éviter les conflits de noms est une exigence de base dans le développement de plugins professionnels. La meilleure pratique consiste à utiliser des prefixes. Pour toutes les classes, fonctions, constantes, et même les variables globales de votre plugin (essayez de les utiliser le moins possible), utilisez un prefix unique et descriptive. Ce prefix peut être l’abréviation ou le nom complet de votre entreprise, ou le nom de votre plugin.
Par exemple, si votre plugin s’appelle “Awesome Gallery”, le préfixe de votre fonction pourrait être… ag_ Ou awesome_gallery_Les noms de classe peuvent être… AG_Core Ou Awesome_Gallery_Admin。
La meilleure approche consiste à encapsuler le code dans une classe, de sorte que la plupart des fonctions existeront sous la forme de méthodes de la classe. $this->method()Cela permet d’éviter la pollution de l’espace de noms global. Pour les fonctions qui doivent être définies dans cet espace, il est essentiel d’utiliser un préfixe long et unique.
Quelle est la suite, quelle est la suite ?
Lecture approfondie et connaissances pratiques
Les articles suivants sont liés au sujet de cet article et peuvent faire l'objet d'une lecture plus approfondie. Il est souvent préférable de commencer par l'article qui se rapproche le plus de votre problème actuel, puis d'étendre progressivement la lecture aux sujets environnants.
- Guide de développement de plugins pour WordPress : Créez votre premier plugin personnalisé de zéro à un
- Devenir développeur de plugins pour WordPress : Un guide complet de A à Z
- Guide complet pour le développement de plugins WordPress : De l’initiation à la maîtrise pour créer des extensions professionnelles
- Développement de plugins pour WordPress : de l’initiation à la maîtrise : Créez votre premier plugin personnalisé
- De zéro à un : Guide complet pour développer votre premier plugin WordPress pas à pas
Français