Domine completamente o desenvolvimento de plugins para o WordPress: crie módulos de funcionalidades personalizadas do zero.

Começando do zero: Preparativos e configuração do ambiente

Antes de começar a escrever o primeiro plugin, é necessário fazer uma preparação adequada. Isso inclui entender a estrutura básica dos plugins do WordPress, configurar um ambiente de desenvolvimento local seguro e compreender a filosofia central do desenvolvimento de plugins.

Um plugin típico do WordPress é um arquivo localizado no diretório /plugins/. /wp-content/plugins/ Um diretório independente dentro do conteúdo principal. O núcleo desse diretório é um arquivo PHP principal que possui um cabeçalho específico. Esse arquivo não apenas contém as informações metadadas do plugin, mas também serve como ponto de entrada para todas as funcionalidades do plugin. Existem duas maneiras de iniciar o plugin: uma delas é através da combinação de funções orientadas a procedimentos, e a outra é utilizando uma estrutura de classes orientada a objetos. A segunda abordagem é mais recomendada no desenvolvimento de plugins modernos devido à sua melhor capacidade de encapsulamento e organização do código.

O ambiente de desenvolvimento local é essencial para um desenvolvimento eficiente. Recomendamos o uso de ferramentas como XAMPP, Local by Flywheel ou Docker para criar um ambiente de execução que integre Apache/Nginx, MySQL e PHP. Isso permite que você faça testes e depurações livremente sem afetar o site em produção.

Leitura recomendada Começando do zero: Guia Completo para o Desenvolvimento de Plugins para WordPress e Partilha de Melhores Práticas。

Construindo a estrutura de um plugin: Arquitetura e arquivos principais

Nesta seção, será detalhado como criar, do zero, a estrutura básica de um plugin que atenda aos padrões do WordPress. Uma boa estrutura é a base para que um plugin seja estável, seguro e fácil de manter.

Hospedagem para sites WordPress da UltraHost

Garantia de reembolso em 30 dias, largura de banda ilimitada e banco de dados, proteção contra DDoS gratuita; desconto de 50% na compra de 3 anos (planos de 4 TB a 10 TB).

página de acesso

Criar os arquivos principais dos plugins essenciais.

A vida de um plugin começa a partir de um arquivo principal. O nome desse arquivo geralmente é o mesmo que o nome da pasta onde o plugin está localizado. Por exemplo, se a pasta do seu plugin se chamar… my-custom-pluginEntão, o arquivo principal pode ser nomeado como… my-custom-plugin.phpNo topo deste arquivo, você deve usar um bloco de comentários que segue um formato específico para declarar as informações do plugin. Isso é essencial para que o WordPress reconheça o plugin e o exiba na lista de gerenciamento do painel administrativo.

A seguir, está um exemplo de cabeçalho de arquivo de plugin o mais básico possível:

<?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
 */

O “Nome do Plugin” é obrigatório nessa anotação; os demais campos são opcionais, mas sua preenchimento é recomendado. “Domínio do Texto” (Text Domain) e “Caminho do Domínio” (Domain Path) são utilizados para a internacionalização (i18n) do plugin, preparando-o para ser traduzido para vários idiomas.

Arquivos e diretórios dos plugins da organização

Com o aumento das funcionalidades dos plugins, não é aconselhável acumular todo o código no arquivo principal. Uma estrutura de plugins bem organizada geralmente inclui vários subdiretórios e arquivos. Uma estrutura comum é a seguinte:

Leitura recomendada O guia completo para o desenvolvimento de plug-ins do WordPress: um tutorial prático do zero à publicação on-line。

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

Nos my-custom-plugin.php No arquivo principal, geralmente não escrevemos a lógica de negócios diretamente, mas o utilizamos como um “iniciador” (starter), responsável por conter os arquivos necessários e inicializar as classes centrais.

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

Links para o núcleo do WordPress: Ganchos de ações e filtros

O sistema de plugins do WordPress é tão poderoso porque oferece um grande número de pontos de evento, permitindo que os desenvolvedores alterem ou aprimorem o seu comportamento sem modificar o código central. Esses mecanismos são chamados de “ganchos” (Hooks) e são divididos principalmente em Ações (Actions) e Filtros (Filters). Eles funcionam como uma ponte de interação entre os plugins e o núcleo do WordPress.

Compreender e utilizar os ganchos de ação (action hooks)

Os ganchos de ação (action hooks) permitem que você execute código personalizado quando um evento específico ocorre. Por exemplo, quando um artigo é publicado, quando um usuário faz login ou quando uma página no painel de administração é carregada. add_action() As funções podem “montar” (ou vincular) a sua função a esses pontos de acesso (ou “ganchos”).

hospedagem compartilhada da hosting.com

Alto desempenho com CPUs AMD EPYC, armazenamento SSD NVMe e LiteSpeed, suporte interno especializado 24 horas por dia, 7 dias por semana, medidas de segurança avançadas, incluindo SSL, força bruta, malware e proteção contra DDoS, economia de até 73%

página de acesso

Suponha que você queira adicionar automaticamente uma declaração de direitos autorais no final de um artigo; você pode utilizar para isso… the_content Esse “gancho de ação” (na verdade, é um filtro, mas seu uso é semelhante ao de uma ação; exemplos clássicos costumam usar essa descrição) é mais apropriado para enviar um e-mail de boas-vindas ao usuário após a conclusão do processo de registro.

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

Dominar o uso dos filtros.

Os ganchos de filtro (filter hooks) permitem que você modifique os dados. Quando o WordPress executa um determinado processo, ele passa os dados específicos por uma série de filtros. O seu plugin pode interceptar esses dados, modificá-los e, em seguida, enviá-los de volta. add_filter() Isso pode ser feito usando uma função.

O exemplo mais comum é a modificação do conteúdo exibido nos artigos. Por exemplo, adicionar automaticamente uma imagem de destaque antes do texto de cada artigo como imagem de introdução.

Leitura recomendada Guia de Início para o Desenvolvimento de Plugins no WordPress: Construa o Seu Primeiro Módulo de Funcionalidade Personalizado do Zero。

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

Implementação da funcionalidade do plugin: integração entre o backend e o frontend

Um plugin completo geralmente precisa interagir com o usuário, o que significa que você precisará criar uma interface de gerenciamento para lidar com as configurações, e também pode ser necessário adicionar novas funcionalidades ou conteúdos nas páginas front-end.

Criar uma página de configurações do backend

Disponibilizar uma página de configurações de backend clara para um plugin é essencial para uma boa experiência do usuário. O WordPress oferece várias APIs para adicionar menus principais ou submenus. O processo geralmente envolve duas etapas: registrar os itens do menu e definir as funções de callback correspondentes a esses itens para exibir o conteúdo da página.

Hospedagem Compartilhada InterServer

Hospedagem compartilhada $2.50 USD por mês, primeiro mês $0.1 USD código promocional tryinterserver, 461 scripts de aplicativos em nuvem, instalação com um clique.

página de acesso

A seguir, está um exemplo de como adicionar um item de menu secundário no menu principal “Configurações”:

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>Configurações do meu plugin</h1>
            <form action="/pt/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="pt"/></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 ) . '" />';
    }
}

Exibir as funcionalidades no front-end do site.

Existem várias maneiras de implementar funcionalidades no front-end: através de códigos encurtados (shortcodes), widgets ou modificando a saída existente por meio de APIs. Os códigos encurtados são uma maneira simples e eficaz de permitir que os usuários ativem funções de plugins ao inserir um tag simples no editor de artigos ou páginas.

Para criar códigos curtos, é necessário utilizar… add_shortcode() Função:

// 定义一个简单的短代码，用于显示一个问候语
function my_plugin_greeting_shortcode( $atts ) {
    // 解析短代码属性
    $atts = shortcode_atts( array(
        'name' => '访客',
    ), $atts, 'greeting' );

// 返回输出内容
    return '<p class="my-plugin-greeting">Olá, '. esc_html($atts['name'])'. ‘!</p>'.');
}
add_shortcode( 'greeting', 'my_plugin_greeting_shortcode' );

Os usuários só precisam inserir o texto no editor de artigos. [greeting name="张三"]Nesse caso, a parte frontal do aplicativo (front-end) exibirá o parágrafo “Olá, Zhang San!”.

resumos

O desenvolvimento de plugins para o WordPress é um processo que consiste em integrar ideias personalizadas num ecossistema vasto e complexo, sendo a tecnologia central baseada no entendimento e no uso dos “ganchos” (hooks) de ações (actions) e filtros (filters). Um desenvolvimento bem-sucedido começa com uma estrutura de arquivos clara e modular, o que estabelece uma base sólida para a manutenção e a expansão futuras do plugin. Ao criar páginas de configuração no painel administrativo do WordPress, o plugin torna-se mais amigável ao usuário e fácil de configurar; além disso, funcionalidades podem ser integradas de forma transparente na parte frontal do site através de códigos encurtados (shortcodes), ferramentas auxiliares (widgets) ou APIs personalizadas. A segurança, a compatibilidade com a internacionalização e a qualidade do código são aspectos essenciais que devem ser sempre considerados ao longo de todo o ciclo de desenvolvimento. Seguir os padrões de codificação e as melhores práticas do WordPress não só garante o funcionamento estável do plugin, como também facilita sua integração no ecossistema, proporcionando assim mais benefícios para os usuários.

Perguntas frequentes Perguntas frequentes

Que nível de conhecimento em PHP é necessário para desenvolver plugins para o WordPress?

Para desenvolver um plugin simples, é necessário ter conhecimentos básicos de PHP, como variáveis, funções, instruções condicionais e ciclos. No entanto, para criar plugins de nível comercial que sejam funcionais, seguros e eficientes, é necessário um entendimento mais aprofundado do código, incluindo conceitos de programação orientada a objetos (POO) e do API do WordPress (especialmente as classes relacionadas à manipulação de bancos de dados). wpdbAPIs para solicitações HTTP, melhores práticas de segurança (como validação de dados, escape de caracteres, prevenção de ataques de SQL injection e CSRF), além de conhecimentos básicos de JavaScript e CSS para interações no lado cliente (front-end).

Sugere-se começar modificando os pequenos plugins existentes ou desenvolvendo funcionalidades simples, e a partir daí, aprofundar gradualmente o conhecimento.

Como garantir que o plugin que desenvolvi seja seguro?

Garantir a segurança dos plugins é um processo que envolve várias etapas. Primeiramente, é necessário realizar uma verificação rigorosa e a limpeza de todos os dados recebidos dos usuários ou de fontes externas, como dados de formulários, parâmetros de URL e cookies. Para isso, utilize as funções fornecidas pelo WordPress. sanitize_text_field(), esc_html(), esc_url() e wp_kses() etc.

Em segundo lugar, ao realizar operações no banco de dados, é essencial utilizar… $wpdb Os métodos fornecidos pela classe (como…) prepare() Use instruções (como `PREPStatement`) para evitar injeções SQL. Sempre é necessário realizar a devida escapagem de dados antes de exibi-los no frontend. Para operações que envolvem permissões, utilize sempre funções de verificação de autorização. current_user_can()Além disso, utiliza-se um valor não aleatório (nonce) para verificar a intenção da solicitação, com o objetivo de prevenir a falsificação de solicitações entre sites (Cross-Site Request Forgery – CSRF).

Após o desenvolvimento do plugin, como ele é distribuído e atualizado?

Existem principalmente duas maneiras de distribuir plugins: através do diretório oficial de plugins do WordPress ou fornecendo o download diretamente no próprio site. Se deseja que os plugins sejam instalados com um único clique no painel de administração do usuário e recebam atualizações automáticas, é necessário submetê-los ao diretório oficial. Isso exige que o código do plugin esteja de acordo com a licença GPLv2 (ou uma versão mais recente) e que passe por revisões rigorosas de segurança e qualidade de código.

Após a submissão, o WordPress lerá o código do seu plugin do seu repositório oficial do Subversion (SVN). Você precisará atualizar o número da “Versão” nas anotações do cabeçalho do arquivo principal no repositório SVN e enviar um novo “Tag” que contenha esse número de versão para acionar a notificação de atualização.

Para plugins comerciais, geralmente é criado um serviço de atualização no próprio servidor. Isso envolve a escrita de um verificador de atualizações, que utiliza mecanismos de “ganchos” (hooks) para… pre_set_site_transient_update_pluginsIntegra-se com o sistema de atualizações do WordPress, compara as informações de versão dos servidores remotos e fornece pacotes de atualização.

Como evitar que os nomes de classes e funções em um plugin entrem em conflito com outros plugins?

Evitar conflitos de nomes é um requisito básico no desenvolvimento de plugins profissionais. A melhor prática é o uso de prefixos. Para todas as classes, funções, constantes e até mesmo variáveis globais do seu plugin (tente evitar o uso de variáveis globais o máximo possível), utilize um prefixo único e descritivo. Esse prefixo pode ser a abreviação ou o nome completo da sua empresa ou do nome do plugin.

Por exemplo, se o seu plugin se chamar “Awesome Gallery”, o prefixo da sua função pode ser… ag_ ou awesome_gallery_Os nomes das classes podem ser… AG_Core ou Awesome_Gallery_Admin。

A melhor abordagem é encapsular o código em uma classe, de modo que a maioria das funções exista na forma de métodos da classe. $this->method()Isso evita a contaminação do espaço de nomes global. Para as funções que precisam ser definidas no espaço global, é essencial usar um prefixo longo e único.