Jak stworzyć własną wtyczkę WordPress - podstawy dla początkujących

Artykuł jest częścią przewodnika Wtyczki WordPress — Kompletny Przewodnik.

Czym technicznie jest wtyczka WordPress?

Wtyczka WordPress to w najprostszym ujęciu plik PHP z nagłówkiem rozpoznawanym przez WordPress. Nic więcej. WordPress skanuje folder /wp-content/plugins/, odnajduje pliki z odpowiednim nagłówkiem i wyświetla je na liście dostępnych wtyczek. Po aktywacji WordPress ładuje ten plik przy każdym żądaniu HTTP — i wtyczka może wpinać swój kod w odpowiednie miejsca systemu przez system hooków.

Architektura WordPress opiera się na trzech fundamentalnych konceptach:

Krok 1: Struktura pliku i nagłówek wtyczki

Minimalna wtyczka WordPress to jeden plik PHP w folderze w /wp-content/plugins/. Folder i główny plik powinny mieć tę samą nazwę (slug wtyczki):

/wp-content/plugins/
  moja-wtyczka/
    moja-wtyczka.php

Nagłówek wtyczki to komentarz PHP na początku głównego pliku. WordPress go parsuje i pobiera z niego metadane wtyczki:

<?php
/**
 * Plugin Name:       Moja Wtyczka
 * Plugin URI:        https://example.com/moja-wtyczka
 * Description:       Krótki opis tego, co robi wtyczka — widoczny na liście wtyczek w panelu.
 * Version:           1.0.0
 * Requires at least: 6.0
 * Requires PHP:      8.0
 * Author:            Jan Kowalski
 * Author URI:        https://example.com
 * License:           GPL v2 or later
 * License URI:       https://www.gnu.org/licenses/gpl-2.0.html
 * Text Domain:       moja-wtyczka
 */

// Zabezpieczenie przed bezpośrednim dostępem do pliku
if ( ! defined( 'ABSPATH' ) ) {
    exit;
}

Jedyne pole obowiązkowe to Plugin Name — bez niego WordPress nie rozpozna pliku. Pozostałe pola są opcjonalne, ale wypełnienie ich to dobra praktyka — szczególnie Requires at least i Requires PHP, które WordPress sprawdza przed aktywacją i ostrzega użytkownika jeśli środowisko nie spełnia wymagań.

Krok 2: System hooków — akcje i filtry

Hooki to serce architektury WordPress. Zamiast modyfikować pliki rdzenia (co byłoby nadpisywane przy każdej aktualizacji WP), wpinasz swój kod w odpowiednie miejsca przez add_action() i add_filter().

Akcje — zrób coś w określonym momencie

// Składnia: add_action( 'nazwa_hooka', 'nazwa_twojej_funkcji', $priorytet, $liczba_argumentów );

// Przykład: dodaj tekst na końcu każdej strony
add_action( 'wp_footer', 'moja_wtyczka_stopka' );

function moja_wtyczka_stopka() {
    echo '<p>Stopka dodana przez moją wtyczkę</p>';
}

Najważniejsze akcje, z których będziesz korzystać:

• init — WordPress zakończył inicjalizację, przed wysłaniem nagłówków HTTP. Tu rejestrujesz typy treści (CPT), taksonomie, shortcody.
• wp_enqueue_scripts — właściwe miejsce do ładowania skryptów JS i arkuszy CSS na front-endzie.
• admin_enqueue_scripts — ładowanie zasobów w panelu administracyjnym.
• admin_menu — dodawanie stron do menu panelu WordPress.
• save_post — wykona się za każdym razem gdy post jest zapisywany.
• wp_footer i wp_head — wstrzykiwanie HTML przed </body> i w <head>.

Filtry — zmodyfikuj istniejącą wartość

// Składnia: add_filter( 'nazwa_filtra', 'nazwa_twojej_funkcji', $priorytet, $liczba_argumentów );

// Przykład: dodaj tekst na końcu każdego wpisu
add_filter( 'the_content', 'moja_wtyczka_dodaj_tekst' );

function moja_wtyczka_dodaj_tekst( $content ) {
    // Tylko dla pojedynczych wpisów, nie na listingach
    if ( is_single() ) {
        $content .= '<p><em>Podobał Ci się ten artykuł? Udostępnij go!</em></p>';
    }
    return $content; // Filtr ZAWSZE musi zwrócić wartość
}

Priorytety hooków

Trzeci argument add_action() i add_filter() to priorytet — liczba całkowita określająca kolejność wykonania gdy wiele funkcji podpiętych jest pod ten sam hook. Domyślnie: 10. Niższy numer = wcześniej; wyższy = później.

// Ta funkcja wykona się przed innymi podpiętymi pod 'init' (priorytet 5 < 10)
add_action( 'init', 'moja_funkcja_wczesna', 5 );

// Ta funkcja wykona się po innych (priorytet 20 > 10)
add_action( 'init', 'moja_funkcja_pozna', 20 );

Krok 3: Prawidłowe ładowanie skryptów i stylów

Nie dodawaj skryptów JS i CSS przez echo w nagłówku ani bezpośrednio do hooków wp_head. WordPress ma własny system kolejkowania zasobów — wp_enqueue_scripts — który zarządza zależnościami, eliminuje duplikaty i pozwala innym wtyczkom i motywowi usuwać lub nadpisywać zasoby.

add_action( 'wp_enqueue_scripts', 'moja_wtyczka_zasoby' );

function moja_wtyczka_zasoby() {

    // Rejestracja i kolejkowanie arkusza CSS
    wp_enqueue_style(
        'moja-wtyczka-style',              // Unikalna nazwa (handle)
        plugin_dir_url( __FILE__ ) . 'css/style.css',  // Ścieżka do pliku
        array(),                           // Zależności (inne style, które muszą być załadowane pierwsze)
        '1.0.0'                            // Wersja — wymusza odświeżenie cache przeglądarki po aktualizacji
    );

    // Rejestracja i kolejkowanie skryptu JS
    wp_enqueue_script(
        'moja-wtyczka-script',
        plugin_dir_url( __FILE__ ) . 'js/script.js',
        array( 'jquery' ),                 // Zależność: jQuery musi być załadowane wcześniej
        '1.0.0',
        true                               // true = ładuj w stopce (przed ), nie w 
    );

    // Przekaż dane z PHP do JavaScript
    wp_localize_script(
        'moja-wtyczka-script',             // Handle skryptu, do którego dołączamy dane
        'MojaWtyczka',                     // Nazwa globalnego obiektu JS
        array(
            'ajaxUrl' => admin_url( 'admin-ajax.php' ),
            'nonce'   => wp_create_nonce( 'moja-wtyczka-nonce' ),
        )
    );
}

if ( is_page( 'kontakt' ) ) {
    wp_enqueue_script( 'moja-wtyczka-script', ... );
}

Krok 4: Shortcody — własne tagi w treści

Shortcod to tag wpisywany w treści wpisu lub strony, który WordPress zamienia na HTML wygenerowany przez Twoją funkcję. To najłatwiejszy sposób, żeby właściciel strony mógł osadzić funkcjonalność wtyczki w treści bez pisania kodu.

// Rejestruj shortcody na hooku 'init'
add_action( 'init', 'moja_wtyczka_rejestruj_shortcody' );

function moja_wtyczka_rejestruj_shortcody() {
    add_shortcode( 'moj-shortcode', 'moja_wtyczka_shortcode_callback' );
}

// Callback shortcodu — zawsze musi ZWRACAĆ HTML, nie echo-wać go
function moja_wtyczka_shortcode_callback( $atts, $content = null ) {

    // Domyślne atrybuty shortcodu — nadpisywane przez to co wpisze użytkownik
    $atts = shortcode_atts( array(
        'kolor'  => 'niebieski',
        'rozmiar' => 'normalny',
    ), $atts, 'moj-shortcode' );

    // Zabezpiecz wartości przed XSS
    $kolor  = sanitize_text_field( $atts['kolor'] );
    $rozmiar = sanitize_text_field( $atts['rozmiar'] );

    // Zbuduj HTML używając output buffering lub konkatenacji
    ob_start();
    ?>
    <div class="moj-element kolor-<?php echo esc_attr( $kolor ); ?>">
        <p>Kolor: <?php echo esc_html( $kolor ); ?> | Rozmiar: <?php echo esc_html( $rozmiar ); ?></p>
        <?php if ( $content ) : ?>
            <div class="tresc"><?php echo wp_kses_post( $content ); ?></div>
        <?php endif; ?>
    </div>
    <?php
    return ob_get_clean(); // Zwróć bufor — NIE echo!
}

Użycie w treści wpisu:

[moj-shortcode kolor="czerwony" rozmiar="duzy"]Treść wewnątrz shortcodu[/moj-shortcode]

Krok 5: Zapisywanie i odczytywanie opcji

WordPress ma wbudowane API do przechowywania ustawień wtyczki w bazie danych — w tabeli wp_options. Trzy kluczowe funkcje:

// Zapisz opcję (tworzy lub aktualizuje)
update_option( 'moja_wtyczka_kolor', 'niebieski' );

// Odczytaj opcję (drugi argument to wartość domyślna jeśli opcja nie istnieje)
$kolor = get_option( 'moja_wtyczka_kolor', 'szary' );

// Usuń opcję
delete_option( 'moja_wtyczka_kolor' );

Krok 6: Strona ustawień w panelu WordPress

Większość wtyczek potrzebuje strony konfiguracyjnej w panelu administracyjnym. WordPress udostępnia Settings API do budowania bezpiecznych stron ustawień z wbudowaną obsługą walidacji i wyświetlania błędów.

// 1. Dodaj pozycję menu
add_action( 'admin_menu', 'moja_wtyczka_menu' );

function moja_wtyczka_menu() {
    add_options_page(
        'Ustawienia Mojej Wtyczki',   // Tytuł strony (w tagu <title>)
        'Moja Wtyczka',               // Tekst w menu bocznym
        'manage_options',             // Wymagane uprawnienie (tylko administratorzy)
        'moja-wtyczka',               // Slug strony (unikalne ID)
        'moja_wtyczka_strona_ustawien' // Funkcja renderująca stronę
    );
}

// 2. Zarejestruj ustawienia przez Settings API
add_action( 'admin_init', 'moja_wtyczka_rejestruj_ustawienia' );

function moja_wtyczka_rejestruj_ustawienia() {
    register_setting(
        'moja_wtyczka_grupa',     // Nazwa grupy opcji
        'moja_wtyczka_kolor',     // Nazwa opcji w bazie danych
        array(
            'sanitize_callback' => 'sanitize_text_field', // Sanityzacja przed zapisem
            'default'           => 'niebieski',
        )
    );

    add_settings_section(
        'moja_wtyczka_sekcja_glowna',
        'Ustawienia ogólne',
        '__return_false', // Opcjonalny opis sekcji
        'moja-wtyczka'
    );

    add_settings_field(
        'moja_wtyczka_pole_kolor',
        'Kolor domyślny',
        'moja_wtyczka_pole_kolor_render',
        'moja-wtyczka',
        'moja_wtyczka_sekcja_glowna'
    );
}

// 3. Renderuj pole formularza
function moja_wtyczka_pole_kolor_render() {
    $wartosc = get_option( 'moja_wtyczka_kolor', 'niebieski' );
    echo '<input type="text" name="moja_wtyczka_kolor" value="' . esc_attr( $wartosc ) . '">';
}

// 4. Renderuj całą stronę ustawień
function moja_wtyczka_strona_ustawien() {
    // Sprawdź uprawnienia
    if ( ! current_user_can( 'manage_options' ) ) {
        return;
    }
    ?>
    <div class="wrap">
        <h1><?php echo esc_html( get_admin_page_title() ); ?></h1>
        <form method="post" action="options.php">
            <?php
            settings_fields( 'moja_wtyczka_grupa' );
            do_settings_sections( 'moja-wtyczka' );
            submit_button( 'Zapisz ustawienia' );
            ?>
        </form>
    </div>
    <?php
}

Dobre praktyki przy tworzeniu wtyczek WordPress

Bezpieczeństwo — niezbywalne minimum

• Sanityzuj dane wejściowe — każda wartość z $_POST, $_GET lub bazy danych może zawierać złośliwy kod. Używaj: sanitize_text_field(), sanitize_email(), absint(), wp_kses_post().
• Escapuj dane wyjściowe — przed wyświetleniem w HTML zawsze escapuj: esc_html() dla zwykłego tekstu, esc_attr() dla atrybutów HTML, esc_url() dla URLi, wp_kses_post() dla HTML z tagami.
• Sprawdzaj uprawnienia — przed każdą operacją wrażliwą (zapis danych, zmiana konfiguracji) wywołaj current_user_can().
• Używaj nonce przy formularzach — nonce (number used once) to token weryfikujący, że żądanie pochodzi z Twojego formularza, a nie z zewnętrznej strony:

// W formularzu (generuj nonce)
wp_nonce_field( 'moja_akcja', 'moj_nonce' );

// Przy obsłudze POST (weryfikuj nonce)
if ( ! isset( $_POST['moj_nonce'] ) || ! wp_verify_nonce( $_POST['moj_nonce'], 'moja_akcja' ) ) {
    wp_die( 'Weryfikacja bezpieczeństwa nie powiodła się.' );
}

Namespace i prefiksy — unikaj kolizji

Wszystkie nazwy funkcji, klas, stałych i opcji w bazie danych poprzedzaj unikalnym prefiksem lub używaj przestrzeni nazw PHP (namespace). Bez tego ryzykujesz kolizję z inną wtyczką, która ma funkcję o tej samej nazwie — co kończy się błędem fatalnym PHP.

// Źle — ogólna nazwa łatwa o kolizję
function dodaj_naglowek() { ... }

// Dobrze — unikalny prefiks
function moja_wtyczka_dodaj_naglowek() { ... }

// Jeszcze lepiej — klasa z namespace
namespace MojaFirma\MojaWtyczka;

class NaglowekManager {
    public function dodaj() { ... }
}

Używaj wbudowanych funkcji WordPress zamiast własnych

WordPress oferuje bogaty zestaw API — do obsługi bazy danych ($wpdb), żądań HTTP (wp_remote_get()), plików (WP_Filesystem), e-maili (wp_mail()), cron (wp_schedule_event()). Używaj ich zamiast bezpośrednich zapytań SQL, file_get_contents(), mail() — masz wtedy automatyczną obsługę błędów i kompatybilność z WP.

Przygotuj czystą deinstalację

Zaimplementuj register_uninstall_hook(), który usuwa z bazy danych wszystkie opcje i tabele stworzone przez Twoją wtyczkę gdy użytkownik ją usunie. To sygnał szanującego deweloperstwa:

register_uninstall_hook( __FILE__, 'moja_wtyczka_odinstaluj' );

function moja_wtyczka_odinstaluj() {
    delete_option( 'moja_wtyczka_kolor' );
    delete_option( 'moja_wtyczka_ustawienia' );
    // Jeśli tworzyłeś własne tabele — usuń je tutaj
}

Struktura plików większej wtyczki

Gdy wtyczka rośnie powyżej kilkuset linii kodu — warto podzielić ją na pliki. Popularna struktura:

moja-wtyczka/
  moja-wtyczka.php          ← Główny plik z nagłówkiem, ładuje resztę
  includes/
    class-core.php          ← Główna klasa wtyczki
    class-admin.php         ← Funkcje panelu administracyjnego
    class-frontend.php      ← Funkcje front-endu
    helpers.php             ← Funkcje pomocnicze
  admin/
    css/
      admin-style.css
    js/
      admin-script.js
    views/
      settings-page.php     ← Szablon strony ustawień
  public/
    css/
      style.css
    js/
      script.js
  languages/                ← Pliki tłumaczeń (.pot, .po, .mo)
  readme.txt                ← Wymagany przy publikacji w WordPress.org

Krok 7: Własne typy treści (Custom Post Types)

WordPress obsługuje domyślnie posty i strony. Gdy Twoja wtyczka potrzebuje przechowywać własny rodzaj danych — produkty, oferty pracy, portfolio, recenzje — rejestrujesz własny typ treści (Custom Post Type, CPT). CPT korzysta z całej infrastruktury WordPressa: edytor wpisów, taksonomie, metadane, REST API, zapytania WP_Query.

add_action( 'init', 'moja_wtyczka_rejestruj_cpt' );

function moja_wtyczka_rejestruj_cpt() {
    register_post_type( 'oferta_pracy', array(
        'labels' => array(
            'name'          => 'Oferty pracy',
            'singular_name' => 'Oferta pracy',
            'add_new_item'  => 'Dodaj nową ofertę',
            'edit_item'     => 'Edytuj ofertę',
        ),
        'public'       => true,       // Widoczny na front-endzie i w panelu
        'has_archive'  => true,       // Strona archiwum /oferty-pracy/
        'show_in_rest' => true,       // Dostępny w edytorze Gutenberg i REST API
        'supports'     => array( 'title', 'editor', 'thumbnail', 'excerpt' ),
        'menu_icon'    => 'dashicons-businessman',
        'rewrite'      => array( 'slug' => 'oferty-pracy' ),
    ) );
}

// WAŻNE: po zarejestrowaniu nowego CPT odśwież reguły przepisywania URL
// Najprościej: wejdź w Ustawienia → Bezpośrednie odnośniki i kliknij "Zapisz"
// Programowo (np. przy aktywacji wtyczki):
register_activation_hook( __FILE__, function() {
    moja_wtyczka_rejestruj_cpt();
    flush_rewrite_rules();
} );

Do CPT możesz też dodać własne taksonomie (odpowiednik kategorii lub tagów dla Twojego nowego typu treści):

add_action( 'init', 'moja_wtyczka_rejestruj_taksonomie' );

function moja_wtyczka_rejestruj_taksonomie() {
    register_taxonomy( 'branża', 'oferta_pracy', array(
        'labels'       => array(
            'name'          => 'Branże',
            'singular_name' => 'Branża',
        ),
        'hierarchical' => true,  // true = jak kategorie; false = jak tagi
        'show_in_rest' => true,
        'rewrite'      => array( 'slug' => 'branza' ),
    ) );
}

Krok 8: Meta pola — dodatkowe dane do wpisów

Każdy wpis WordPress może mieć nieograniczoną liczbę dodatkowych pól danych (post meta) — przechowywanych w tabeli wp_postmeta. Dla CPT „Oferta pracy" możesz przechowywać np. lokalizację, typ umowy, widełki wynagrodzenia. Nowoczesny sposób to rejestracja meta pól przez REST API z wbudowaną walidacją i sanityzacją:

add_action( 'init', 'moja_wtyczka_rejestruj_meta' );

function moja_wtyczka_rejestruj_meta() {
    register_post_meta( 'oferta_pracy', 'wynagrodzenie', array(
        'type'              => 'integer',
        'description'       => 'Wynagrodzenie w PLN (brutto)',
        'single'            => true,
        'default'           => 0,
        'show_in_rest'      => true,       // Dostępne przez REST API i w Gutenbergu
        'sanitize_callback' => 'absint',   // Sanityzacja: tylko dodatnie liczby całkowite
        'auth_callback'     => function() {
            return current_user_can( 'edit_posts' );
        },
    ) );

    register_post_meta( 'oferta_pracy', 'lokalizacja', array(
        'type'              => 'string',
        'single'            => true,
        'default'           => '',
        'show_in_rest'      => true,
        'sanitize_callback' => 'sanitize_text_field',
        'auth_callback'     => function() {
            return current_user_can( 'edit_posts' );
        },
    ) );
}

// Odczyt i zapis meta pól
$wynagrodzenie = get_post_meta( $post_id, 'wynagrodzenie', true );
update_post_meta( $post_id, 'wynagrodzenie', 8000 );
delete_post_meta( $post_id, 'wynagrodzenie' );

Krok 9: REST API — udostępnij dane z wtyczki

WordPress REST API pozwala udostępniać i odbierać dane przez endpoint HTTP — np. dla aplikacji mobilnej, headless frontendu w React/Vue lub integracji z zewnętrznym systemem. Rejestracja własnego endpointu to kilkanaście linii kodu:

add_action( 'rest_api_init', 'moja_wtyczka_rejestruj_endpoint' );

function moja_wtyczka_rejestruj_endpoint() {
    register_rest_route(
        'moja-wtyczka/v1',   // Namespace — nazwa_wtyczki/wersja
        '/oferty',            // Ścieżka endpointu
        array(
            'methods'             => WP_REST_Server::READABLE,  // GET
            'callback'            => 'moja_wtyczka_endpoint_oferty',
            'permission_callback' => '__return_true', // Publiczny endpoint
            // Dla chronionych endpointów:
            // 'permission_callback' => function() {
            //     return current_user_can( 'read' );
            // },
        )
    );
}

function moja_wtyczka_endpoint_oferty( WP_REST_Request $request ) {
    $oferty = get_posts( array(
        'post_type'      => 'oferta_pracy',
        'posts_per_page' => 10,
        'post_status'    => 'publish',
    ) );

    $dane = array_map( function( $oferta ) {
        return array(
            'id'           => $oferta->ID,
            'tytul'        => $oferta->post_title,
            'lokalizacja'  => get_post_meta( $oferta->ID, 'lokalizacja', true ),
            'wynagrodzenie' => get_post_meta( $oferta->ID, 'wynagrodzenie', true ),
            'url'          => get_permalink( $oferta->ID ),
        );
    }, $oferty );

    return rest_ensure_response( $dane );
}

// Dostęp przez URL: https://twojadomena.pl/wp-json/moja-wtyczka/v1/oferty

Narzędzia i środowisko pracy

Dobry warsztat skraca czas developmentu i eliminuje całe klasy błędów. Oto zestaw narzędzi, których używają profesjonalni deweloperzy WordPress:

Lokalne środowisko WordPress

Edytor i rozszerzenia

• VS Code z rozszerzeniami: PHP Intelephense (podpowiadanie kodu PHP), WordPress Snippets (snippety WP API), PHP CS Fixer (automatyczne formatowanie według WPCS)
• PhpStorm — płatny, ale najlepsze wsparcie dla PHP i WordPress w IDE. Szczególnie wartościowy przy większych projektach.

Narzędzia diagnostyczne

• Query Monitor — błędy PHP, hooki, zapytania SQL, czas wykonania bezpośrednio w pasku WP
• WP Debug Bar — dodatkowe informacje o środowisku i stanie WordPressa
• WP-CLI — zarządzanie WordPressem przez terminal, niezastąpione przy automatyzacji i testowaniu
• PHP_CodeSniffer + WPCS — statyczna analiza kodu pod kątem WordPress Coding Standards

Testowanie

• WP-CLI scaffold plugin-tests — generuje szkielet testów PHPUnit dla Twojej wtyczki
• PHPUnit — testy jednostkowe i integracyjne dla kodu PHP
• Playwright / Cypress — testy end-to-end sprawdzające działanie wtyczki w przeglądarce

Gdzie szukać dalszej wiedzy

• developer.wordpress.org — Plugin Handbook, Theme Handbook, REST API, Block Editor API. Pierwsze miejsce przy każdym pytaniu o WordPress API.
• GenerateWP.com — generatory boilerplate dla CPT, taksonomii, shortcode'ów, meta pól — przyspieszają start nowego projektu.
• WordPress Coding Standards (WPCS) — PHP_CodeSniffer z ruleset WPCS. Obowiązkowe przed publikacją w repozytorium WordPress.org.
• Query Monitor — debugowanie hooków, zapytań SQL i błędów PHP w czasie rzeczywistym.
• wp-cli.org — dokumentacja WP-CLI z pełną listą komend do zarządzania WordPress i tworzenia scaffoldingu wtyczek.

Nie chcesz pisać wtyczki samodzielnie?

Tworzenie własnej wtyczki WordPress daje pełną kontrolę — ale wymaga czasu, znajomości PHP i ciągłego utrzymania kodu. Jeśli potrzebujesz konkretnej funkcjonalności na swojej stronie lub w sklepie WooCommerce, a nie chcesz inwestować w naukę WP development — możemy napisać wtyczkę na zamówienie.

Zamów własną wtyczkę WordPress →

FAQ — tworzenie wtyczek WordPress

Czy muszę znać PHP żeby stworzyć wtyczkę WordPress?

Tak — PHP jest językiem, w którym napisany jest WordPress i w którym piszesz wtyczki. Nie musisz być ekspertem: podstawy (zmienne, funkcje, tablice, warunki, pętle) wystarczą do prostych wtyczek. JavaScript jest potrzebny gdy tworzysz interaktywne elementy front-endu lub bloki Gutenberga (React).

Czy mogę opublikować swoją wtyczkę w repozytorium WordPress.org?

Tak — repozytorium jest otwarte dla każdego. Prześlij wtyczkę przez formularz na wordpress.org/plugins/developers/add, przejdź przegląd kodu przez zespół WordPress (kilka tygodni) i spełnij wymagania: licencja GPL, standardy kodowania, brak złośliwego kodu, poprawny plik readme.txt. Publikacja jest bezpłatna.

Jak debugować własną wtyczkę?

Włącz tryb debug w wp-config.php:

define( 'WP_DEBUG', true );
define( 'WP_DEBUG_LOG', true );
define( 'WP_DEBUG_DISPLAY', false ); // Nie pokazuj błędów odwiedzającym

Błędy PHP lądują w /wp-content/debug.log. Zainstaluj Query Monitor — wyświetla błędy, hooki, zapytania SQL i czas wykonania bezpośrednio w pasku admina.

Jaka jest różnica między wtyczką a motywem potomnym?

Motyw potomny nadpisuje wygląd i szablony — jest powiązany z konkretnym motywem rodzicem i traci sens po jego zmianie. Wtyczka dodaje funkcjonalność niezależnie od aktywnego motywu. Własny kod PHP dodający nowe funkcje powinien zawsze trafiać do wtyczki, nigdy do functions.php motywu — inaczej tracisz go przy zmianie lub aktualizacji motywu.

Jak zarejestrować blok Gutenberga we własnej wtyczce?

Bloki Gutenberga rejestrujesz przez register_block_type() w PHP oraz odpowiadający mu kod JavaScript (React). Najprostszy punkt startowy to scaffolding przez WP-CLI:

wp scaffold block moj-blok --title="Mój Blok" --plugin=moja-wtyczka

Wygeneruje gotowy szkielet bloku z plikami PHP, JS i CSS — gotowy do rozbudowania. Pełna dokumentacja: developer.wordpress.org/block-editor/.

Czy wtyczka napisana samodzielnie jest bezpieczna?

Bezpieczeństwo zależy od przestrzegania zasad: sanityzuj dane wejściowe, escapuj dane wyjściowe, sprawdzaj uprawnienia, używaj nonce przy formularzach. Pomiń choćby jeden z tych kroków i wtyczka może stać się wektorem ataku. Jeśli Twoja wtyczka obsługuje dane wrażliwe lub płatności — zlecenie audytu bezpieczeństwa komuś z doświadczeniem w WP security jest rozsądną inwestycją.

Chcesz zgłębić temat zarządzania wtyczkami od strony użytkownika? Wróć do kompletnego przewodnika po wtyczkach WordPress.

← Wtyczki WordPress — Kompletny Przewodnik

Zamów wtyczkę WordPress na zamówienie →