Title: Pag-develop gamit ang Hooks
Published: 2 July 2025

---

[Home](https://learn.wordpress.org)[Lessons](https://learn.wordpress.org/lessons/)
Pag-develop gamit ang Hooks

[Exit lesson](https://learn.wordpress.org/lessons/)

# Pag-develop gamit ang Hooks

Habang mas lumalalim ka sa pag-develop gamit ang WordPress hooks, may ilang detalye
tungkol sa kung paano gumagana ang hooks na mahalagang maintindihan.

Sa araling ito, matututuhan mo ang ilang magagandang gawain na dapat sundin kapag
nagde-develop gamit ang hooks.

## Pagpapangalan ng Hooks

Ang unang magandang gawin ay ang tamang pagpapangalan ng iyong hooks. Tingnan natin
ang ilang convention na sinusunod ng WordPress core.

### Actions

Karaniwang idinadagdag ang mga actions kapag may nagbabago, kaya mainam na gumamit
ng verb na may kaugnayan sa pagbabagong iyon sa pangalan ng action hook.

Halimbawa, ang WordPress core action hook na na-trigger kapag nabura ang isang post
ay pinangalanang delete_post.

    ```php
    do_action( 'delete_post' );
    ```

Kung gusto mong magdagdag ng action bago ang aktwal na pagbabago, maaari mong lagyan
ng prefix na pre_.

    ```php
    do_action( 'pre_delete_post' );
    ```

Sa huli, kung gusto mong magdagdag ng action pagkatapos ng aktwal na event, ang 
convention ay gumamit ng past tense sa pangalan.

    ```php
    do_action( 'deleted_post' );
    ```

### Filters

Dahil ang filters ay karaniwang konektado sa isang variable na maaaring baguhin,
ang mga filter hook ay madalas na ipinapangalan batay sa variable na maaaring baguhin.

Halimbawa, ang filter hook na nagpapahintulot sa iyo na baguhin ang content ng isang
post ay pinangalanang the_content.

    ```php
    $content = apply_filters( 'the_content', get_the_content() );
    ```

### Iwasan ang Pagkakapareho ng Pangalan

Kapag nagpapangalan ng iyong hooks, mahalagang iwasan ang pagkakapareho ng pangalan
sa ibang plugins o themes. Para magawa ito, maaari mong lagyan ng prefix ang pangalan
ng iyong hook gamit ang pangalan ng iyong plugin o isang natatanging identifier.

    ```php
    do_action( 'wp_learn_delete_book' );

    apply_filters( 'wp_learn_lesson_url', 'https://example.org/lesson' );
    ```

## Pag-handle ng Uri ng Filter

Kapag gumagamit ng filter, ang uri ng variable na ibinabalik mula sa filter ay hindi
garantisado, kahit na ito ay naka-dokumento.

### Ang Problema

Ang dahilan nito ay ang huling callback na tumakbo sa filter ang nagtatakda kung
ano ang ibabalik ng filter.

Maaaring hindi ito mukhang problema sa una, dahil bilang developer, sisiguraduhin
mong magbabalik ka ng value na may parehong uri.

Gayunpaman, kung naaalala mo mula sa aralin tungkol sa Custom Hooks, tulad ng kaya
mong mag-hook sa actions at filters, kaya rin ito ng ibang developers.

![Flowchart showing data passed through filter and user callbacks.](https://i0.wp.
com/learn.wordpress.org/files/2024/12/Handling-filter-return.png?resize=1920%2C1080&
ssl=1)

Ibig sabihin, kung magdadagdag ka ng custom hooks sa iyong plugin, kailangan mong
tiyakin na ang data na ibinabalik ay tama ang uri, kung hindi ay maaaring masira
ang functionality ng iyong plugin.

### Ang Solusyon

Ang solusyon dito ay may dalawang bahagi:

#### Pag-validate ng Output ng Filter

Ang pinakamagandang paraan para matiyak na ang value na ibinabalik mula sa anumang
filter callback ay nananatiling uri na inaasahan mo ay i-validate ang uri ng data
sa iyong code.

Para sa mga primitive types tulad ng integer, float, o boolean, maaari mong gamitin
ang [type casting ng PHP](https://www.php.net/manual/en/language.types.type-juggling.php#language.types.typecasting)
para matiyak na tama ang uri ng return value.

 * `boolean`: `$is_admin = (bool) apply_filters( 'wp_learn_is_admin', true );`
 * `integer`: `$book_count = (int) apply_filters( 'wp_learn_book_count', 10 );`
 * `float`: `$base_price = (float) apply_filters( 'wp_learn_base_price', 10.0 );`

Gayunpaman, para sa mas komplikadong validation o ibang uri, mas mainam na magpatupad
ng mas manu-manong validation check.

Halimbawa, para sa string o array, mas mainam na i-check kung tama ang uri ng value
na ibinalik kaysa gumamit ng casting, dahil maaari itong magdulot ng PHP fatal error.

Halimbawa, maaari mong gamitin ang PHP is_string() [function](https://www.php.net/manual/en/function.is-string.php)
para i-check kung ang value na ibinalik mula sa anumang hooked callback ay string.

    ```php
    $book_slug = apply_filters( 'wp_learn_book_slug', 'books' );

    if ( ! is_string( $book_slug ) ) {
        // either reset the value or throw an error
    }
    ```

Kung hindi, maaari mong i-reset ang value o mag-throw ng error.

#### I-assert ang Value ng Iyong Callback

Ang katotohanang ang uri ng variable na ibinabalik mula sa filter ay maaaring mabago
ay nangangahulugan din na ang maling uri ng variable ay maaaring maipasa sa anumang
hooked callback.

![Flowchart showing filter applying multiple callbacks, including user and plugin
code](https://i0.wp.com/learn.wordpress.org/files/2024/12/Assert-callback-values.
png?resize=1920%2C1080&ssl=1)

Kaya, kung mag-ho-hook ka ng callback function sa filter, mahalagang laging i-check
ang uri ng value na natatanggap mo bago gumawa ng anumang operasyon dito.

    ```php
    add_filter( 'wp_learn_book_slug', 'jon_doe_edit_book_slug' );
    function jon_doe_edit_book_slug( $book_slug ) {
        if ( ! is_string( $book_slug ) ) {
            // throw some error because the type is incorrect 
        }

        // continue with your functionality because the type is correct
        return 'book';
    }
    ```

Maaari mong gamitin ang parehong paraan tulad ng nabanggit sa itaas para i-validate
ang uri ng variable na natatanggap mo.

Para sa karagdagang impormasyon tungkol sa type jugging ng PHP, maaari kang sumangguni
sa [PHP documentation](https://www.php.net/manual/en/language.types.type-juggling.php).

Mayroon ding seksyon na nakalaan para sa iba’t ibang [Variable handling functions](https://www.php.net/manual/en/ref.var.php).

## Pagkuha ng Impormasyon Tungkol sa Hook

Isa pang magandang malaman tungkol sa hooks ay kung paano kumuha ng impormasyon 
tungkol dito.

### Pag-alam sa Kasalukuyang Hook

Pinapayagan ng WordPress na ang callback function o method ay magamit sa higit sa
isang hook.

Dahil dito, minsan ay hindi malinaw kung saang hook talaga tumatakbo ang callback.

Sa anumang callback function, maaari mong gamitin ang [current_filter](https://developer.wordpress.org/reference/functions/current_filter/)
o [current_action](https://developer.wordpress.org/reference/functions/current_action/)
functions para malaman kung saang filter o action tumatakbo ang callback.

### Suriin Kung Ilang Beses Nang Tumakbo ang Hook

Minsan mahalagang malaman kung ang hooked callback ay tumakbo na upang maiwasan 
itong tumakbo muli.

Sa loob ng anumang callback function, maaari mong gamitin ang [did_filter](https://developer.wordpress.org/reference/functions/did_filter/)
function para malaman kung ilang beses na na-apply ang filter sa kasalukuyang request
at ang [did_action](https://developer.wordpress.org/reference/functions/did_action/)
function para malaman kung ilang beses na na-apply ang action.

##  Suggestions

 Found a typo, grammar error or outdated screenshot? [Contact us](https://learn.wordpress.org/report-content-feedback/).