Os plug-ins são uma parte vital dos sites WordPress que precisam de funcionalidades específicas.
Embora o repositório oficial do WordPress tenha mais de 45.000 plug-ins para você escolher, muitos deles erram o alvo.
Só porque um plug-in está no repositório não significa que ele não prejudicará seu desempenho ou comprometerá sua segurança.
Então o que você pode fazer? Bem, você pode construir o seu próprio.
Construindo um ótimo plugin WordPress começa com um planejamento cuidadoso.
Esteja você construindo um do zero ou com base em um padrão, seguir as práticas recomendadas bem documentadas é absolutamente essencial.
Neste tutorial, você aprenderá a construir um plug-in WordPress simples da maneira certa.
Se quiser revisar o código-fonte final enquanto lê, você pode encontrá-lo Aqui .
Primeiro, vamos listar os recursos que nosso plug-in terá e descrever exatamente o que ele precisa fazer.
O plug-in que estamos construindo permitirá que os visitantes do site salvem conteúdo para ler mais tarde.
Para usuários registrados, vamos armazenar a lista no banco de dados, e para usuários anônimos, vamos salvar a lista usando cookies.
Abaixo está um esboço dos recursos e funcionalidades que nosso plugin irá fornecer.
As mensagens abaixo aparecerão na tela em resposta à interação do visitante com o plug-in ou como rótulos em itens acionáveis:
É aqui que os visitantes visualizam a lista de postagens que salvaram.
Com um shortcode, a página salva pode ser renderizada onde quer que seja adicionada.
Este é o melhor clichê Encontrei. É bem estruturado, orientado a objetos e eficiente. Ele segue todas as melhores práticas. E é rápido e leve.
Você pode usar esta página para gerar uma base de código de plug-in com base neste Boilerplate de plug-in do WordPress:
Você deveria obter um .fecho eclair Arquivo.
Extraia-o e coloque-o na pasta de instalação do WordPress: wp-content / plugins / .
Se você abrir seu painel do WordPress e for para plug-ins, verá que seu plug-in está listado lá. Não o ative ainda.
É importante que nosso plug-in lide com a ativação e desativação de maneira adequada.
Quando nosso plug-in for ativado, criaremos uma página chamada 'Salvo', que conterá os itens salvos do usuário.
Ao criar essa página, adicionaremos um código curto para nossos itens salvos no conteúdo dessa página.
No final, vamos salvar a página; obtenha seu ID; e armazená-lo no banco de dados, para que possamos acessá-lo posteriormente na desativação do plugin.
Quando nosso plugin for desativado, obteremos o ID da página “Salvo” do banco de dados e, em seguida, excluiremos a página “Salvo”, removendo qualquer vestígio do próprio plugin.
Podemos fazer tudo isso em inclui / class-toptal-save-activator.php e inclui / class-toptal-save-deactivator.php .
Vamos começar com o processo de ativação:
__( 'Saved', 'toptal-save' ), 'post_content' => '[toptal-saved]', 'post_status' => 'publish', 'post_type' => 'page' ); // Insert the page and get its id. $saved_page_id = wp_insert_post( $saved_page_args ); // Save page id to the database. add_option( 'toptal_save_saved_page_id', $saved_page_id ); } }
O activate()
função é chamada quando o plugin é ativado.
Ele cria uma nova página usando o wp_insert_post()
função e salva o ID da página no banco de dados usando add_option()
.
Agora, vamos prosseguir com a desativação do plugin.
O deactivate()
função, que é chamada quando o plugin é desativado, recupera a página usando o get_option()
função, remove a página correspondente do banco de dados usando wp_delete_post()
e remove o ID salvo da tabela de opções usando delete_option()
.
Se ativarmos nosso plugin e irmos para as páginas, devemos ver uma página chamada “Salvo” com um shortcode nela.

Se desativarmos o plugin, essa página será removida.
Como usamos true
como um argumento em nosso wp_delete_post()
, esta página não irá para a lixeira, mas será excluída completamente.
Crie uma página de configurações do plugin.
Podemos criar nossa página de configurações dentro do admin / class-toptal-save-admin.php arquivo, e a primeira coisa que precisamos fazer nesse arquivo é remover ou comentar a chamada para wp_enqueue_style()
dentro de enqueue_styles()
função e chamada para wp_enqueue_script()
dentro de enqueue_scripts()
função se não adicionarmos CSS / JS à tela de administrador.
No entanto, se vamos adicionar algum estilo, recomendo carregar esses arquivos apenas na página de configurações do nosso plugin, em vez de em todas as páginas de administração do WordPress. Podemos fazer isso colocando o seguinte código diretamente acima das linhas que comentamos:
if ( 'tools_page_toptal-save' != $hook ) { return; } wp_enqueue_style( $this->plugin_name, plugin_dir_url( __FILE__ ) . 'css/toptal-save-admin.css', array(), $this->version, 'all' );
if ( 'tools_page_toptal-save' != $hook ) { return; } wp_enqueue_script( $this->plugin_name, plugin_dir_url( __FILE__ ) . 'js/toptal-save-admin.js', array( 'jquery' ), $this->version, false );
Se você está se perguntando onde consegui isso ‘tools_page_toptal-save’
parte de.
Bem, aqui está, eu sei que vou criar uma página de configurações com um slug toptal-save e também sei que vou adicioná-la às Ferramentas ( tools.php ) tela. Então, colocando esses dois juntos, podemos dizer que o valor da variável $hook
vai ser ‘tools_page_toptal-save’
- uma concatenação dos dois valores.
Se não estivermos em nossa página de configurações de plug-in, usamos return
para encerrar imediatamente a execução da função em que estamos.
Já que não vou adicionar nenhum estilo personalizado à tela do administrador - porque quero que a tela do plug-in se pareça com a tela nativa do WordPress - não vou adicionar esse código.
Agora, podemos prosseguir com a criação de nossa página de configurações.
Vamos começar adicionando um método simples a ApeeScape_Save_Admin
classe que chamará add_submenu_page()
função.
/** * Register the settings page for the admin area. * * @since 1.0.0 */ public function register_settings_page() { // Create our settings page as a submenu page. add_submenu_page( 'tools.php', // parent slug __( 'ApeeScape Save', 'toptal-save' ), // page title __( 'ApeeScape Save', 'toptal-save' ), // menu title 'manage_options', // capability 'toptal-save', // menu_slug array( $this, 'display_settings_page' ) // callable function ); }
É um punhado de argumentos que estamos passando para o add_submenu_page()
função. Aqui está o que cada um deles significa.
-
Lesma-mãe: O nome do slug para o menu pai (ou o nome do arquivo de uma página de administração padrão do WordPress). Você pode ver a lista completa dos slugs pais Aqui .
-
Título da página: O texto a ser exibido nas tags de título da página quando o menu é selecionado.
-
Título do menu: O texto a ser usado para o título do menu.
-
Capacidade: A capacidade exigida pelo usuário para que este menu seja exibido a eles. Usamos “manage_options” que permite acesso às opções do painel de administração. Você pode ler mais sobre funções e capacidades em Aqui .
-
Slug de menu: O nome do slug para se referir a este menu.
-
Função chamável: A função a ser chamada para produzir o conteúdo desta página. Como definimos o nome de nossa função que pode ser chamada, precisamos criá-la, mas antes de fazermos, usamos $this
para fazer referência a uma instância de uma classe de dentro dela mesma. Aqui está o que a documentação PHP tem a dizer sobre isso:
A pseudo-variável $ this está disponível quando um método é chamado de dentro de um contexto de objeto. $ this é uma referência ao objeto de chamada (geralmente o objeto ao qual o método pertence, mas possivelmente outro objeto, se o método for chamado estaticamente a partir do contexto de um objeto secundário).
A seguir, adicionaremos outro método à classe:
/** * Display the settings page content for the page we have created. * * @since 1.0.0 */ public function display_settings_page() { require_once plugin_dir_path( dirname( __FILE__ ) ) . 'admin/partials/toptal-save-admin-display.php'; }
Esta função chamável está incluindo nosso modelo que irá mostrar nossa página de configurações. Você pode ver que estamos nos referindo a um arquivo localizado no admin / parciais chamado toptal-save-admin-display.php .
Agora, se você for em Ferramentas, não verá essa tela. Por quê? Porque não fisgamos nosso register_admin_page()
método para o admin_menu
gancho.
Podemos fazer isso abrindo nosso inclui / class-toptal-save.php e adicionando este pedaço de código dentro do define_admin_hooks()
, logo abaixo de onde o $plugin_admin = new ApeeScape_Save_Admin( $this->get_plugin_name(), $this->get_version() );
parte é.
/** * Register all of the hooks related to the admin area functionality * of the plugin. * * @since 1.0.0 * @access private */ private function define_admin_hooks() { $plugin_admin = new ApeeScape_Save_Admin( $this->get_plugin_name(), $this->get_version() ); $this->loader->add_action( 'admin_menu', $plugin_admin, 'register_settings_page' ); $this->loader->add_action( 'admin_enqueue_scripts', $plugin_admin, 'enqueue_styles' ); $this->loader->add_action( 'admin_enqueue_scripts', $plugin_admin, 'enqueue_scripts' ); }
Não se preocupe com as ligações para add_action()
já que isso é algo que vamos cobrir mais tarde.
Por enquanto, basta abrir a página Ferramentas e você poderá ver a página Salvar do ApeeScape. Se o abrirmos, funciona, mas vemos uma tela em branco, pois não há nada nela.

Estamos fazendo algum progresso, mas ei, precisamos exibir algumas configurações aqui, então vamos fazer isso.
Vamos começar a criar os campos, e isso é algo que faremos com a ajuda de API de configurações do WordPress .
Se você não estiver familiarizado com ele, ele nos permite criar campos de formulário que podemos usar para salvar nossos dados.
/** * Register the settings for our settings page. * * @since 1.0.0 */ public function register_settings() { // Here we are going to register our setting. register_setting( $this->plugin_name . '-settings', $this->plugin_name . '-settings', array( $this, 'sandbox_register_setting' ) ); // Here we are going to add a section for our setting. add_settings_section( $this->plugin_name . '-settings-section', __( 'Settings', 'toptal-save' ), array( $this, 'sandbox_add_settings_section' ), $this->plugin_name . '-settings' ); // Here we are going to add fields to our section. add_settings_field( 'post-types', __( 'Post Types', 'toptal-save' ), array( $this, 'sandbox_add_settings_field_multiple_checkbox' ), $this->plugin_name . '-settings', $this->plugin_name . '-settings-section', array( 'label_for' => 'post-types', 'description' => __( 'Save button will be added only to the checked post types.', 'toptal-save' ) ) ); // ... }
Dentro do register_settings()
função podemos adicionar e configurar todos os campos. Você pode encontrar a implementação completa da função Aqui . Usamos o seguinte na função mostrada acima:
-
register_setting()
: Registra uma configuração e seu retorno de chamada de higienização. -
add_settings_section()
: Adiciona uma nova seção a uma página de configurações. -
add_settings_field()
: Adiciona um novo campo a uma seção de uma página de configurações.
Sempre que usamos uma dessas três funções, um retorno de chamada de limpeza era fornecido. Isso permite que os dados sejam higienizados e, se for um campo, mostrar o elemento HTML apropriado (caixa de seleção, rádio, entrada, etc).
Além disso, passamos um array de dados para esses callbacks, como label_for, description ou default conforme necessário.
Agora, podemos criar esses retornos de chamada de higienização. Você pode encontrar o código para esses retornos de chamada Aqui .
Está tudo bem, entretanto, precisamos conectar os campos em admin_init
anexe e mostre a eles.
Usaremos add_action
que é um gancho que o núcleo do WordPress inicia em pontos específicos durante a execução, ou quando um evento específico ocorre. admin_init
é disparado antes de qualquer outro gancho quando um usuário acessa a área administrativa.
Primeiro, precisamos adicionar uma ação em inclui / class-toptal-save.php Arquivo.
/** * Register all of the hooks related to the admin area functionality * of the plugin. * * @since 1.0.0 * @access private */ private function define_admin_hooks() { $plugin_admin = new ApeeScape_Save_Admin( $this->get_plugin_name(), $this->get_version() ); // Hook our settings page $this->loader->add_action( 'admin_menu', $plugin_admin, 'register_settings_page' ); // Hook our settings $this->loader->add_action( 'admin_init', $plugin_admin, 'register_settings' ); $this->loader->add_action( 'admin_enqueue_scripts', $plugin_admin, 'enqueue_styles' ); $this->loader->add_action( 'admin_enqueue_scripts', $plugin_admin, 'enqueue_scripts' ); }
Próximo, em admin / partials / topal-save-admin-display.php , precisamos fornecer uma visão para a área administrativa de nosso plugin:
O settings_fields()
function é usado para gerar campos nonce, action e option_page para uma página de configurações.
É seguido por do_settings_sections()
que imprime todas as seções de configurações adicionadas a uma página de configurações específica.
Finalmente, um botão de envio é adicionado usando o texto fornecido e as classes apropriadas usando submit_button()
função.
Agora, se dermos uma olhada em nossa página, ela ficará assim:

Isso é tudo que temos que fazer em nossa área administrativa. Vamos começar a trabalhar na parte pública do nosso plugin.
Crie a funcionalidade do plugin.
Aí vem a parte interessante. Precisamos criar várias funções para separar nossa funcionalidade:
- Uma função que mostrará o botão “Salvar item”. Isso precisa verificar se o usuário atual já salvou esse item ou não, dependendo disso, mostraremos textos e cores diferentes.
- Uma função que irá salvar / remover um item (AJAX).
- Uma função que mostrará todos os itens salvos.
- Uma função que irá gerar nossos códigos de acesso.
Então, vamos começar mostrando o botão. Faremos tudo isso em public / class-toptal-save-public.php .
Enquanto fazemos isso, precisaremos criar algumas funções auxiliares adicionais para cuidar de certas coisas como:
- Criação de um nome de cookie exclusivo para o site
- Criação de um cookie
- Obtendo o valor do cookie
- Obtendo o status de membro nas configurações
O código para essas funções auxiliares pode ser encontrado Aqui .
O get_unique_cookie_name()
A função nos ajudará a gerar um nome de cookie exclusivo a partir do URL do site, nome do site e nosso sufixo personalizado definido. Isso ocorre para que o nome do cookie gerado não entre em conflito quando usado em vários sites WordPress sob o mesmo domínio.
O toptal_set_cookie()
e toptal_get_cookie()
funções criarão e obterão o valor de nossos cookies, respectivamente.
O get_user_status()
A função obterá o status de nossa caixa de seleção de associação nas configurações (retornando 1 quando marcada, 0 caso contrário).
Agora a parte suculenta, criar a função que será responsável por mostrar o botão salvar. A implementação do nosso show_save_button()
função pode ser encontrada Aqui . E usamos algumas novas funções da API do WordPress aqui:
-
get_queried_object_id()
: Recupera o ID do objeto consultado no momento. -
is_user_logged_in()
: Verifica se o visitante atual é um usuário conectado. -
get_user_meta()
: Recupera o campo de metadados do usuário para um usuário. -
wp_create_nonce()
: Cria um token criptográfico vinculado a uma ação, usuário, sessão de usuário e janela de tempo específicos.
Agora, vamos criar uma função que anexará nosso botão ao final do conteúdo. Aqui, temos dois requisitos principais.
- Certifique-se de que o botão seja mostrado apenas no (s) tipo (s) de postagem selecionado (s) nas configurações.
- Certifique-se de que a caixa de seleção para anexar o botão esteja marcada.
/** * Append the button to the end of the content. * * @since 1.0.0 */ public function append_the_button( $content ) { // Get our item ID $item_id = get_queried_object_id(); // Get current item post type $current_post_type = get_post_type( $item_id ); // Get our saved page ID, so we can make sure that this button isn't being shown there $saved_page_id = get_option( 'toptal_save_saved_page_id' ); // Set default values for options that we are going to call below $post_types = array(); $override = 0; // Get our options $options = get_option( $this->plugin_name . '-settings' ); if ( ! empty( $options['post-types'] ) ) { $post_types = $options['post-types']; } if ( ! empty( $options['toggle-content-override'] ) ) { $override = $options['toggle-content-override']; } // Let's check if all conditions are ok if ( $override == 1 && ! empty( $post_types ) && ! is_page( $saved_page_id ) && in_array( $current_post_type, $post_types ) ) { // Append the button $custom_content = ''; ob_start(); echo $this->show_save_button(); $custom_content .= ob_get_contents(); ob_end_clean(); $content = $content . $custom_content; } return $content; }
Agora, precisamos conectar essa função ao the_content
gancho.
Por quê? Porque the_content
é usado para filtrar o conteúdo da postagem depois que ela for recuperada do banco de dados e antes de ser impressa na tela.
Com isso, podemos adicionar nosso botão Salvar em qualquer lugar do conteúdo. Podemos fazer isso em inclui / class-toptal-save.php em define_public_hooks()
método, como este:
/** * Register all of the hooks related to the public-facing functionality * of the plugin. * * @since 1.0.0 * @access private */ private function define_public_hooks() { $plugin_public = new ApeeScape_Save_Public( $this->get_plugin_name(), $this->get_version() ); // Append our button $this->loader->add_action( 'the_content', $plugin_public, 'append_the_button', 45 ); $this->loader->add_action( 'wp_enqueue_scripts', $plugin_public, 'enqueue_styles' ); $this->loader->add_action( 'wp_enqueue_scripts', $plugin_public, 'enqueue_scripts' ); }
Agora, se você for para as configurações do plug-in e verificar as postagens e páginas, além de anexar o botão, veremos em qualquer postagem do blog que o botão é mostrado.

A partir daqui, devemos prosseguir e estilizar esse botão.
Podemos fazer isso em public / css / toptal-save-public.css . Encontre o arquivo CSS atualizado Aqui .
Agora, vamos criar uma função que realmente salvará o item.
Faremos isso em nossa aula pública e faremos com AJAX. O código é Aqui .
Vamos ligar essa função ao WordPress AJAX.
/** * Register all of the hooks related to the public-facing functionality * of the plugin. * * @since 1.0.0 * @access private */ private function define_public_hooks() { $plugin_public = new ApeeScape_Save_Public( $this->get_plugin_name(), $this->get_version() ); // Append our button $this->loader->add_action( 'the_content', $plugin_public, 'append_the_button', 45 ); // Save/unsave AJAX $this->loader->add_action( 'wp_ajax_save_unsave_item', $plugin_public, 'save_unsave_item' ); $this->loader->add_action( 'wp_ajax_nopriv_save_unsave_item', $plugin_public, 'save_unsave_item' ); $this->loader->add_action( 'wp_enqueue_scripts', $plugin_public, 'enqueue_styles' ); $this->loader->add_action( 'wp_enqueue_scripts', $plugin_public, 'enqueue_scripts' ); }
Você pode ler mais sobre AJAX em plug-ins Aqui .
Antes de terminarmos esta parte, precisamos fazer mais duas coisas.
- Localize um script.
- Crie nossa chamada AJAX em public / js / toptal-save-public.js
A localização de um script será feita por meio do wp_localize_script()
função dentro de nossa public/class-toptal-save-public.php
Arquivo.
Além disso, enquanto estamos nisso, também vamos implementar a exibição de arquivos CSS e JS, dependendo do estado de nossa caixa de seleção 'use nosso estilo'.
/** * Register the stylesheets for the public-facing side of the site. * * @since 1.0.0 */ public function enqueue_styles() { /** * This function is provided for demonstration purposes only. * * An instance of this class should be passed to the run() function * defined in ApeeScape_Save_Loader as all of the hooks are defined * in that particular class. * * The ApeeScape_Save_Loader will then create the relationship * between the defined hooks and the functions defined in this * class. */ $options = get_option( $this->plugin_name . '-settings' ); if ( ! empty( $options['toggle-css-override'] ) && $options['toggle-css-override'] == 1 ) { wp_enqueue_style( $this->plugin_name, plugin_dir_url( __FILE__ ) . 'css/toptal-save-public.css', array(), $this->version, 'all' ); } } /** * Register the JavaScript for the public-facing side of the site. * * @since 1.0.0 */ public function enqueue_scripts() { /** * This function is provided for demonstration purposes only. * * An instance of this class should be passed to the run() function * defined in ApeeScape_Save_Loader as all of the hooks are defined * in that particular class. * * The ApeeScape_Save_Loader will then create the relationship * between the defined hooks and the functions defined in this * class. */ wp_enqueue_script( $this->plugin_name, plugin_dir_url( __FILE__ ) . 'js/toptal-save-public.js', array( 'jquery' ), $this->version, false ); // Get our options $options = get_option( $this->plugin_name . '-settings' ); // Get our text $item_save_text = $options['text-save']; $item_unsave_text = $options['text-unsave']; $item_saved_text = $options['text-saved']; $item_no_saved = $options['text-no-saved']; $saved_page_id = get_option( 'toptal_save_saved_page_id' ); $saved_page_url = get_permalink( $saved_page_id ); wp_localize_script( $this->plugin_name, 'toptal_save_ajax', array( 'ajax_url' => admin_url( 'admin-ajax.php' ), 'item_save_text' => $item_save_text, 'item_unsave_text' => $item_unsave_text, 'item_saved_text' => $item_saved_text, 'item_no_saved' => $item_no_saved, 'saved_page_url' => $saved_page_url ) ); }
Agora, podemos prosseguir com nossa chamada AJAX.
Nosso script de front-end procurará elementos com a classe “botão salvar na parte superior”.
Um manipulador de cliques será registrado para todos os elementos correspondentes, o que realizará a chamada da API e atualizará a IU de acordo.
Você pode encontrar o código Aqui e o CSS necessário Aqui .
Também adicionei uma função que tratará da notificação quando o item for adicionado.
É assim que tudo funciona.

Em seguida, precisamos criar um código de acesso para os usuários inserirem onde quiserem.
Podemos fazer isso em public / class-toptal-save-public.php :
/** * Create Shortcode for Users to add the button. * * @since 1.0.0 */ public function register_save_unsave_shortcode() { return $this->show_save_button(); }
Também precisamos registrá-lo, já que a função por si só não fará nada.
Dentro inclui / class-toptal-save.php adicione este código após a linha onde acrescentamos nosso botão.
// Add our Shortcodes $this->loader->add_shortcode( 'toptal-save', $plugin_public, 'register_save_unsave_shortcode' );
Agora, isso não vai funcionar porque ainda não carregamos o add_shortcode()
método dentro de nossa classe de carregador.
Aqui é o código completo do inclui / class-toptal-save-loader.php Arquivo.
Eu adicionei uma nova variável protegida chamada shortcodes
, então no método do construtor da classe, eu a transformei em um array.
Na linha 104, adicionei uma função que será responsável pela criação de nossos códigos de acesso; você pode ver que é praticamente igual à função acima (add_filter()
), exceto que mudei o “filtro” para “shortcode” e “filtros” para “shortcodes”.
Além disso, no run()
método, adicionei outro foreach
que irá percorrer nosso array de shortcodes e registrá-los com o WordPress.
Essa foi fácil.
Lembre-se, no início, usamos um shortcode [toptal-saved]
, então vamos criar um método que mostrará todos os nossos itens salvos.
Encontre o código completo para este método Aqui .
Agora, como sempre, precisamos registrar o shortcode em inclui / class-toptal-save.php :
/** * Register all of the hooks related to the public-facing functionality * of the plugin. * * @since 1.0.0 * @access private */ private function define_public_hooks() { $plugin_public = new ApeeScape_Save_Public( $this->get_plugin_name(), $this->get_version() ); // Append our button $this->loader->add_action( 'the_content', $plugin_public, 'append_the_button', 45 ); // Add our Shortcodes $this->loader->add_shortcode( 'toptal-save', $plugin_public, 'register_save_unsave_shortcode' ); $this->loader->add_shortcode( 'toptal-saved', $plugin_public, 'register_saved_shortcode' ); // Save/unsave AJAX $this->loader->add_action( 'wp_ajax_save_unsave_item', $plugin_public, 'save_unsave_item' ); $this->loader->add_action( 'wp_ajax_nopriv_save_unsave_item', $plugin_public, 'save_unsave_item' ); $this->loader->add_action( 'wp_enqueue_scripts', $plugin_public, 'enqueue_styles' ); $this->loader->add_action( 'wp_enqueue_scripts', $plugin_public, 'enqueue_scripts' ); }
Temos mais duas coisas a fazer aqui.
- Estilize nossa página de itens salvos.
- Certifique-se de que, quando um usuário remove um item salvo, ele desaparece da página de itens salvos.
Para a primeira tarefa, você pode encontrar o código CSS necessário Aqui .
Para o segundo, envolve um pouco de script de front-end.
O código JavaScript completo para isso pode ser encontrado Aqui .
Como você verá na linha 52, eu pesquisei o div com uma classe “toptal-saved-item”.
Então, nas linhas 70-75, verificamos se aquele div pai tem uma classe toptal-saved-item.
Em caso afirmativo, ocultamos nosso item com fadeOut e, em seguida, após o término da animação, removemos completamente o item da tela.
Agora, vamos passar para a parte mais difícil - torná-la modular.
Torne o plugin modular.
A definição básica de um plugin modular é:
Código extensível ou modular é o código que pode ser modificado, interagido, adicionado ou manipulado - tudo sem nunca modificar a base do código principal.
Agora, quando se trata deste plugin, gostaria de garantir que os usuários possam alterar o HTML dentro do item salvo na página de itens salvos.
Então, vamos precisar fazer algumas mudanças em nosso register_saved_shortcode()
método:
- Alterar
html_to_return
para inner_html_to_return
onde quisermos que os usuários possam alterar o HTML. Certifique-se de que a primeira declaração do nosso inner_html_to_return
variável tem “=” sem um ponto antes dela. - Use o
apply_filters()
método para registrar nosso filtro.
Com essas duas mudanças, você deve acabar com algo como isto .
Agora, se os usuários desejam interagir com nosso código, eles podem adicionar algo assim dentro de seu functions.php
Arquivo:
Gere arquivos de tradução.
A tradução é muito importante porque permite que membros da comunidade do WordPress e poliglotas traduzam seu plug-in, tornando-o acessível a sites que não sejam em inglês.
Dito isso, vamos mergulhar em alguns detalhes técnicos sobre como o WordPress lida com as traduções.
WordPress usa o GNU gettext
estrutura de localização para tradução. Nesta estrutura, existem três tipos de arquivos:
- Modelo de objeto portátil (POT)
- Objeto portátil (PO)
- Objeto de máquina (MO)
Cada um desses arquivos representa uma etapa do processo de tradução.
Para gerar um arquivo POT, precisamos de um programa que irá pesquisar através do código WordPress e obter todo o texto passado para nossas funções de tradução, como __e()
e _e()
. Você pode ler mais sobre as funções de tradução Aqui .
Aqui traduzimos o texto do arquivo POT, salvando o inglês e a nossa tradução em um arquivo PO, e convertemos o arquivo PO em um arquivo MO.
Fazer isso manualmente levaria muito tempo, pois você teria que escrever algumas linhas de código para cada arquivo traduzível que você tem em seu plugin. Felizmente, existe uma maneira melhor, usando um pequeno e prático plug-in chamado Loco Translate.
Depois de instalar e ativar, vá para Tradutor louco > Plugins> ApeeScape Save.
A partir daí, clique em Editar modelo e depois em Sincronizar e Salvar. Isso editará nosso toptal-save.pot
arquivo dentro de nossa pasta de idiomas.
Agora, o plugin está disponível para tradução.
Construa seu plugin WordPress agora.
Construímos um plugin bastante simples neste artigo, mas no processo, seguimos as práticas e padrões que nos permitiriam manter e estender este plugin facilmente.
executando um servidor web em raspberry pi
Usamos as funcionalidades do WordPress de maneiras que não prejudicam o desempenho geral da plataforma.
Quer seja um plugin simples ou complicado, quer você seja um desenvolvedor individual ou um Empresa de desenvolvimento WordPress , planejando e seguindo Melhores Práticas é a chave para construir um plugin robusto.