WordPress Hooks คืออะไร? Actions และ Filters ต่างกันอย่างไร พร้อมตัวอย่างการใช้งาน

/
/
WordPress Hooks คืออะไร? Actions และ Filters ต่างกันอย่างไร พร้อมตัวอย่างการใช้งาน

WordPress Hooks คือระบบที่ช่วยให้นักพัฒนาสามารถเพิ่ม ปรับเปลี่ยน หรือขยายการทำงานของ WordPress ผ่านจุดเชื่อมต่อที่กำหนดไว้ โดยไม่จำเป็นต้องแก้ไขไฟล์ WordPress Core โดยตรง ซึ่งเป็นพื้นฐานสำคัญของการพัฒนา Plugin, Theme และ Custom Functions

WordPress Hooks แบ่งออกเป็น 2 ประเภทหลัก ได้แก่ Action Hooks และ Filter Hooks โดยทั้งสองประเภทใช้หลักการเชื่อม Callback Function เข้ากับจุดทำงานของระบบ แต่มีหน้าที่แตกต่างกัน

Action Hook ใช้เรียกฟังก์ชันให้ทำงานเมื่อถึงเหตุการณ์หรือช่วงเวลาที่กำหนด เช่น เมื่อ WordPress เริ่มต้นทำงาน เมื่อบันทึกบทความ หรือเมื่อต้องการเพิ่ม HTML ใน Footer

ส่วน Filter Hook ใช้รับข้อมูลที่ถูกส่งผ่านมา ปรับเปลี่ยนค่า และส่งค่าที่ปรับปรุงแล้วกลับไปให้ระบบทำงานต่อ เช่น การเปลี่ยนข้อความ Title เพิ่ม CSS Class หรือปรับเนื้อหาก่อนแสดงผล

การเข้าใจ WordPress Hooks ช่วยให้นักพัฒนาสามารถสร้างฟังก์ชันเฉพาะทาง แก้ไขพฤติกรรม Plugin และเชื่อมระบบต่าง ๆ ได้อย่างเป็นระเบียบ โดยลดความจำเป็นในการแก้ไขไฟล์ของ Plugin หรือ WordPress โดยตรง

บทความนี้จะอธิบายว่า WordPress Hooks คืออะไร Actions และ Filters ต่างกันอย่างไร พร้อมตัวอย่าง PHP วิธีใช้ add_action(), add_filter(), do_action(), apply_filters() การกำหนด Priority และข้อควรระวังสำหรับเว็บไซต์ Production

WordPress Hooks คืออะไร?

WordPress Hooks เป็นส่วนหนึ่งของ WordPress Plugin API ที่เปิดโอกาสให้โค้ดจาก Theme หรือ Plugin เชื่อมเข้ากับกระบวนการทำงานของ WordPress ได้

ลองนึกภาพว่า WordPress มีขั้นตอนการทำงานหลายช่วง เช่น

  1. เริ่มโหลดระบบ WordPress
  2. โหลด Plugin และ Theme
  3. ลงทะเบียน Custom Post Types
  4. ประมวลผล Request
  5. ดึงข้อมูลจากฐานข้อมูล
  6. เตรียมข้อมูลสำหรับแสดงผล
  7. สร้าง HTML
  8. ส่งผลลัพธ์ให้ Browser

ในบางจุด WordPress จะเรียก Hook เพื่อเปิดโอกาสให้โค้ดอื่นเข้ามาทำงานหรือปรับข้อมูล

ตัวอย่างเช่น เมื่อ WordPress เรียก Hook ชื่อ init นักพัฒนาสามารถลงทะเบียนฟังก์ชันที่จะทำงานในช่วงนั้นได้

ตัวอย่าง PHP

function mysite_custom_init() {
    // คำสั่งที่ต้องการให้ทำงาน
}

add_action( 'init', 'mysite_custom_init' );

เมื่อ WordPress เรียก Action Hook ชื่อ init ฟังก์ชัน mysite_custom_init() ก็จะถูกเรียกตามลำดับที่กำหนด

วิธีนี้ช่วยให้สามารถพัฒนาฟังก์ชันเพิ่มเติมโดยไม่ต้องเปิดไฟล์ WordPress Core เพื่อแก้ไขโค้ดเดิม

WordPress Hooks มีทั้งหมดกี่ประเภท?

WordPress Hooks มี 2 ประเภทหลัก ได้แก่

1. Action Hooks

ใช้เรียก Callback Function เพื่อดำเนินการเมื่อถึงจุดหรือเหตุการณ์ที่กำหนด

2. Filter Hooks

ใช้ส่งข้อมูลผ่าน Callback Function เพื่อให้สามารถแก้ไขค่าแล้วส่งกลับไปยังระบบ

ทั้งสองใช้แนวคิด Hook และ Callback เหมือนกัน แต่ต่างกันที่วัตถุประสงค์และการจัดการค่าที่ส่งผ่าน

Action Hooks คืออะไร?

Action Hooks คือจุดที่ WordPress เปิดให้เรียกฟังก์ชันเพิ่มเติมเมื่อเกิดเหตุการณ์หรือเมื่อโปรแกรมทำงานถึงตำแหน่งที่กำหนด

ตัวอย่างการใช้งาน ได้แก่

  • เพิ่มโค้ดเมื่อ WordPress เริ่มทำงาน
  • ลงทะเบียน Custom Post Types
  • ทำงานเมื่อบันทึกบทความ
  • เพิ่ม HTML ใน Footer
  • โหลด CSS และ JavaScript
  • ส่งข้อมูลไปยังระบบภายนอกเมื่อเกิดเหตุการณ์
  • บันทึก Log หลังดำเนินการบางอย่าง

ฟังก์ชันที่เชื่อมกับ Action Hook ไม่จำเป็นต้องคืนค่าให้ Hook เพราะระบบไม่ได้ใช้ Return Value ของ Action Callback เพื่อแทนค่าข้อมูลเดิม

ตัวอย่าง Action Hook

function mysite_add_footer_message() {
    echo '<p>Powered by WordPress</p>';
}

add_action(
    'wp_footer',
    'mysite_add_footer_message'
);

ตัวอย่างนี้ใช้ wp_footer เพื่อแสดงข้อความก่อนส่วนท้ายของเอกสารตามตำแหน่งที่ Theme เรียก Hook

ข้อควรทราบคือ Theme ต้องเรียก wp_footer() อย่างถูกต้อง จึงจะมีการทำงานของ Callback ที่ผูกกับจุดนี้

หากต้องการแสดงผลอย่างมีโครงสร้าง ควรใช้ HTML ที่เหมาะสมและตรวจสอบผลกระทบต่อ Layout

Filter Hooks คืออะไร?

Filter Hooks คือจุดที่ WordPress ส่งข้อมูลให้ฟังก์ชันที่ลงทะเบียนไว้สามารถปรับแก้ก่อนส่งค่ากลับไปใช้งานต่อ

ตัวอย่างเช่น

  • เปลี่ยนข้อความก่อนแสดงผล
  • เพิ่ม CSS Class
  • ปรับค่าใน Array
  • เปลี่ยนข้อมูลบางส่วนของบทความ
  • กำหนดค่า Configuration ผ่าน Filter ที่รองรับ
  • ปรับผลลัพธ์ของฟังก์ชันที่ Plugin เปิดให้แก้ไข

Filter Callback ควรคืนค่าประเภทข้อมูลที่ Hook นั้นคาดหวัง

ตัวอย่าง Filter Hook

function mysite_modify_title( $title ) {
    return 'บทความ: ' . $title;
}

add_filter(
    'the_title',
    'mysite_modify_title'
);

เมื่อ WordPress ส่งข้อความ Title ผ่าน the_title ฟังก์ชันจะเติมคำว่า “บทความ:” ก่อน Title เดิม

ตัวอย่างนี้ใช้เพื่ออธิบายหลักการเท่านั้น หากนำไปใช้จริงโดยไม่มีเงื่อนไข อาจกระทบ Title หลายตำแหน่ง เช่น เมนู Widget หรือรายการบทความ เพราะ Hook เดียวกันอาจถูกเรียกในหลายบริบท

จึงต้องตรวจสอบบริบทและข้อกำหนดของ Hook ก่อนใช้งานบนเว็บไซต์จริง

Actions และ Filters ต่างกันอย่างไร?

ความแตกต่างหลักคือ Action ใช้ทำงานเพิ่มเติม ส่วน Filter ใช้ปรับข้อมูลที่ถูกส่งผ่านมา

หัวข้อAction HooksFilter Hooks
วัตถุประสงค์ดำเนินการเมื่อถึงจุดที่กำหนดปรับเปลี่ยนข้อมูล
ฟังก์ชันลงทะเบียนadd_action()add_filter()
ฟังก์ชันเรียก Hookdo_action()apply_filters()
Return Value ของ Callbackไม่ใช้เป็นค่าผลลัพธ์ของ Hookต้องคืนค่าที่เหมาะสม
ตัวอย่าง Hookinit, wp_footer, save_postthe_title, the_content, body_class
ตัวอย่างงานเพิ่มฟังก์ชันหรือทำงานเมื่อเกิดเหตุการณ์แก้ข้อความหรือข้อมูล
รองรับ Priorityได้ได้
รับ Arguments เพิ่มเติมได้ได้
ใช้สร้าง Custom Hookได้ได้

วิธีจำง่าย ๆ

Action = ทำอะไรบางอย่าง

Filter = เปลี่ยนค่าของบางอย่าง

ทั้งนี้ Action สามารถทำให้ข้อมูลในระบบเปลี่ยนแปลงได้ เช่น บันทึกข้อมูลลงฐานข้อมูล แต่ต่างจาก Filter ตรงที่ไม่ได้ส่ง Return Value กลับไปแทนค่าที่ผ่าน Hook

add_action() คืออะไร?

add_action() เป็นฟังก์ชันสำหรับลงทะเบียน Callback ให้ทำงานเมื่อ Action Hook ที่ระบุถูกเรียก

รูปแบบพื้นฐาน

add_action(
    $hook_name,
    $callback,
    $priority,
    $accepted_args
);

แต่ละ Parameter มีหน้าที่ดังนี้

Parameterความหมาย
$hook_nameชื่อ Action Hook
$callbackฟังก์ชันที่ต้องการให้ทำงาน
$priorityลำดับการทำงาน
$accepted_argsจำนวน Arguments ที่ Callback รับ

ค่าเริ่มต้นของ Priority คือ 10 และค่าเริ่มต้นของ Accepted Arguments คือ 1

ตัวอย่างการใช้งาน add_action()

function mysite_register_custom_function() {
    // Custom functionality
}

add_action(
    'init',
    'mysite_register_custom_function',
    10
);

ตัวอย่างนี้เป็นการลงทะเบียนฟังก์ชันให้ทำงานเมื่อ WordPress เรียก init

add_action() ไม่ได้สั่งให้ Callback ทำงานทันที ณ บรรทัดที่ลงทะเบียน แต่จะรอจน Hook ที่กำหนดถูกเรียก

add_filter() คืออะไร?

add_filter() เป็นฟังก์ชันสำหรับเชื่อม Callback เข้ากับ Filter Hook

รูปแบบพื้นฐาน

add_filter(
    $hook_name,
    $callback,
    $priority,
    $accepted_args
);

ตัวอย่างเพิ่ม CSS Class ใน Body

function mysite_add_body_class( $classes ) {
    $classes[] = 'mysite-custom-layout';

    return $classes;
}

add_filter(
    'body_class',
    'mysite_add_body_class'
);

เมื่อ WordPress ประมวลผล Body Classes ระบบจะส่ง Array ผ่าน Filter และรับ Array ที่ปรับแล้วกลับไปใช้งาน

ข้อสำคัญคือฟังก์ชันต้อง return $classes;

หากไม่คืนค่า Filter อาจส่งผลให้ข้อมูลที่โค้ดส่วนถัดไปได้รับไม่ถูกต้อง

do_action() คืออะไร?

do_action() เป็นฟังก์ชันที่ใช้เรียก Action Hook เพื่อให้ Callback ที่ลงทะเบียนไว้ทำงาน

ตัวอย่าง

do_action( 'mysite_custom_event' );

จากนั้นสามารถลงทะเบียน Callback ได้

function mysite_handle_custom_event() {
    error_log( 'Custom event triggered' );
}

add_action(
    'mysite_custom_event',
    'mysite_handle_custom_event'
);

เมื่อโค้ดทำงานถึง do_action( 'mysite_custom_event' ) ระบบจะเรียก Callback ที่เชื่อมกับ Hook นั้น

ตัวอย่างนี้ใช้สำหรับการสาธิต โดย error_log() จะบันทึกข้อความตามการตั้งค่า PHP Logging ของเซิร์ฟเวอร์

ในงาน Production ควรใช้ Logging อย่างเหมาะสมและหลีกเลี่ยงการบันทึกข้อมูลส่วนบุคคลหรือข้อมูลลับ

apply_filters() คืออะไร?

apply_filters() ใช้ส่งค่าผ่าน Filter Hook เพื่อให้ Callback สามารถแก้ไขข้อมูลและคืนค่ากลับมา

ตัวอย่าง

$label = apply_filters(
    'mysite_button_label',
    'อ่านเพิ่มเติม'
);

สามารถเพิ่ม Callback เพื่อเปลี่ยนข้อความได้

function mysite_change_button_label( $label ) {
    return 'ดูรายละเอียด';
}

add_filter(
    'mysite_button_label',
    'mysite_change_button_label'
);

ผลลัพธ์ในตัวแปร $label จะเป็นข้อความ

ดูรายละเอียด

ตัวอย่างนี้แสดงให้เห็นว่าระบบใช้ Return Value จาก Filter Callback เพื่อสร้างค่าผลลัพธ์

add_action() กับ do_action() ต่างกันอย่างไร?

ทั้งสองเกี่ยวข้องกับ Action Hooks แต่ทำหน้าที่คนละส่วน

add_action() ใช้ลงทะเบียน Callback

do_action() ใช้เรียก Hook ให้ Callback ทำงาน

ตัวอย่าง

function mysite_notify_event() {
    error_log( 'Event executed' );
}

add_action(
    'mysite_event',
    'mysite_notify_event'
);

do_action( 'mysite_event' );

ลำดับการทำงานคือ

  1. ลงทะเบียน mysite_notify_event()
  2. เมื่อเรียก do_action( 'mysite_event' )
  3. WordPress ค้นหา Callback ที่ผูกกับ Hook
  4. เรียกฟังก์ชันตาม Priority

หากไม่มี Callback ที่ลงทะเบียนไว้ การเรียก do_action() ก็ไม่จำเป็นต้องสร้างผลลัพธ์ที่มองเห็นได้

add_filter() กับ apply_filters() ต่างกันอย่างไร?

add_filter() ใช้ลงทะเบียนฟังก์ชันปรับข้อมูล

apply_filters() ใช้ส่งข้อมูลผ่าน Filter และรับค่าที่ผ่านการประมวลผลแล้วกลับมา

ตัวอย่าง

function mysite_format_price( $price ) {
    return '฿' . number_format( $price, 2 );
}

add_filter(
    'mysite_price_display',
    'mysite_format_price'
);

$display_price = apply_filters(
    'mysite_price_display',
    1500
);

ผลลัพธ์

฿1,500.00

ควรสังเกตว่า Filter เปลี่ยนค่าตัวเลขเป็นข้อความสำหรับการแสดงผล

ดังนั้น หากมีระบบอื่นต้องนำผลลัพธ์ไปคำนวณต่อ ต้องออกแบบให้ชัดเจนว่า Hook นั้นใช้สำหรับข้อมูลดิบหรือข้อมูลแสดงผล

WordPress Hook Priority คืออะไร?

Priority คือค่าที่ใช้กำหนดลำดับการทำงานของ Callback ภายใน Hook เดียวกัน

ค่าเริ่มต้นคือ 10

Callback ที่มี Priority ต่ำกว่าจะทำงานก่อน Callback ที่มี Priority สูงกว่า

ตัวอย่าง

function mysite_first_action() {
    error_log( 'First' );
}

function mysite_second_action() {
    error_log( 'Second' );
}

add_action(
    'init',
    'mysite_first_action',
    5
);

add_action(
    'init',
    'mysite_second_action',
    20
);

เมื่อ Hook init ทำงาน ฟังก์ชันที่ Priority 5 จะถูกเรียกก่อนฟังก์ชันที่ Priority 20

หาก Priority เท่ากันจะเกิดอะไรขึ้น?

ถ้า Callback อยู่บน Hook เดียวกันและมี Priority เท่ากัน โดยทั่วไป WordPress จะเรียกตามลำดับที่ลงทะเบียนไว้

แต่ไม่ควรพึ่งพาลำดับการโหลด Plugin โดยไม่มีการตรวจสอบ หากลำดับการทำงานมีความสำคัญต่อฟังก์ชัน

Priority ควรตั้งเท่าไร?

ไม่มีค่าที่ดีที่สุดสำหรับทุกกรณี

ควรเริ่มจาก Priority 10 ซึ่งเป็นค่าเริ่มต้น และปรับเมื่อมีเหตุผลชัดเจนว่าต้องทำงานก่อนหรือหลัง Callback อื่น

accepted_args คืออะไร?

accepted_args คือจำนวน Arguments ที่ Callback ต้องการรับจาก Hook

ตัวอย่าง Action Hook save_post ส่งข้อมูลเกี่ยวกับบทความที่บันทึก

function mysite_after_save_post(
    $post_id,
    $post,
    $update
) {
    // Process post data.
}

add_action(
    'save_post',
    'mysite_after_save_post',
    10,
    3
);

ตัวเลข 3 หมายถึง Callback รับ Arguments ได้สูงสุดสามตัวจาก Hook นี้

ต้องตรวจเอกสารของ Hook ที่ใช้จริง เพราะแต่ละ Hook ส่ง Arguments แตกต่างกัน

หาก Callback ต้องการ Arguments มากกว่าที่ Hook ส่งมา อาจเกิดข้อผิดพลาดจากจำนวน Arguments ที่ไม่ตรงกับฟังก์ชัน

ตัวอย่าง WordPress Action Hooks ที่ใช้บ่อย

WordPress มี Action Hooks จำนวนมาก โดยแต่ละ Hook ทำงานในช่วงต่างกัน

Action Hookใช้สำหรับ
initเริ่มต้นฟังก์ชันหลังโหลดส่วนสำคัญของ WordPress
after_setup_themeตั้งค่าความสามารถของ Theme
wp_enqueue_scriptsลงทะเบียนและโหลด Assets ฝั่ง Frontend
admin_enqueue_scriptsโหลด Assets ในหน้า Admin
wp_headเพิ่มองค์ประกอบในส่วน Head ตาม Hook ที่ Theme เรียก
wp_footerเพิ่มองค์ประกอบบริเวณท้ายเอกสาร
save_postดำเนินการเมื่อมีการบันทึก Post
template_redirectประมวลผลก่อนโหลด Template ตามบริบทที่รองรับ
admin_initเริ่มต้นงานบางประเภทใน Admin
rest_api_initลงทะเบียนความสามารถที่เกี่ยวข้องกับ REST API

ควรศึกษาเอกสารของแต่ละ Hook ก่อนใช้ เพราะชื่อ Hook เพียงอย่างเดียวไม่ได้อธิบายครบว่าถูกเรียกเมื่อไรหรืออยู่ใน Request ประเภทใด

ตัวอย่าง WordPress Filter Hooks ที่ใช้บ่อย

Filter Hookใช้สำหรับ
the_titleปรับข้อความ Title ในบริบทที่เรียก Filter
the_contentปรับเนื้อหา Post ก่อนใช้แสดงผล
the_excerptปรับ Excerpt
body_classเพิ่มหรือแก้ CSS Classes ของ Body
post_classเพิ่มหรือแก้ CSS Classes ของ Post
excerpt_lengthกำหนดความยาว Excerpt ในบริบทที่ใช้ Filter
excerpt_moreปรับข้อความท้าย Excerpt
upload_mimesปรับรายการ MIME Types ที่อนุญาตให้อัปโหลด
script_loader_tagปรับ HTML Script Tag ที่ WordPress สร้าง
pre_get_document_titleปรับ Document Title ตามรูปแบบที่ Hook รองรับ

การแก้ไข Filter ต้องตรวจชนิดข้อมูลที่ได้รับและส่งกลับ รวมถึงผลกระทบต่อ Plugin หรือ Theme อื่น

ตัวอย่างที่ 1: ใช้ Action เพิ่ม CSS และ JavaScript อย่างถูกต้อง

หากต้องการโหลด CSS เพิ่มเติม ควรใช้ระบบ Enqueue ของ WordPress แทนการแทรก <link> ด้วยตนเองทุกหน้า

ตัวอย่าง

function mysite_enqueue_custom_styles() {
    wp_enqueue_style(
        'mysite-custom',
        plugin_dir_url( __FILE__ ) . 'assets/custom.css',
        array(),
        '1.0.0'
    );
}

add_action(
    'wp_enqueue_scripts',
    'mysite_enqueue_custom_styles'
);

ตัวอย่างนี้สมมติว่าโค้ดอยู่ในไฟล์หลักของ Custom Plugin และมีไฟล์ assets/custom.css อยู่ในตำแหน่งที่ระบุ

หากนำไปใช้ใน functions.php ของ Theme ต้องเปลี่ยนวิธีอ้างอิง Path ให้เหมาะสม เช่น ใช้ฟังก์ชันสำหรับ Theme Directory

การ Enqueue ช่วยให้ WordPress และ Plugin อื่นสามารถจัดการ Dependencies และ Assets ได้เป็นระบบมากขึ้น

ตัวอย่างที่ 2: ใช้ Filter เพิ่ม Class เฉพาะหน้า

สมมติว่าต้องการเพิ่ม CSS Class ให้หน้า Blog Post

function mysite_single_post_class( $classes ) {
    if ( is_singular( 'post' ) ) {
        $classes[] = 'mysite-single-post';
    }

    return $classes;
}

add_filter(
    'body_class',
    'mysite_single_post_class'
);

เมื่อเปิดหน้า Single Post ระบบจะเพิ่ม Class ดังกล่าวใน <body>

สามารถนำไปใช้กับ CSS ได้ เช่น

.mysite-single-post .entry-content {
    line-height: 1.8;
}

ข้อดีคือไม่จำเป็นต้องแก้ไฟล์ Template เพื่อเพิ่ม Class สำหรับทุกบทความด้วยตนเอง

ตัวอย่างที่ 3: ใช้ Filter เพิ่มข้อความท้ายบทความ

ตัวอย่างนี้เพิ่มข้อความท้ายเนื้อหาของ Post เมื่อแสดงผลบนหน้า Single Post ฝั่ง Frontend

function mysite_add_content_notice( $content ) {
    if (
        is_admin() ||
        ! is_singular( 'post' ) ||
        ! in_the_loop() ||
        ! is_main_query()
    ) {
        return $content;
    }

    $notice = '<p class="mysite-content-note">';
    $notice .= esc_html(
        'เนื้อหานี้จัดทำเพื่อให้ความรู้'
    );
    $notice .= '</p>';

    return $content . $notice;
}

add_filter(
    'the_content',
    'mysite_add_content_notice'
);

ตัวอย่างนี้มีเงื่อนไขเพื่อช่วยลดผลกระทบจากการเรียก the_content ในหลายบริบท

แต่ยังต้องทดสอบกับ Theme, Block Editor, REST API และ Plugin ที่ใช้จริง เพราะการแสดงผลเนื้อหาอาจมีรูปแบบซับซ้อนกว่าตัวอย่างพื้นฐาน

หากต้องเพิ่มข้อความในทุกบทความ ควรประเมินด้วยว่าการใช้ Template หรือ Block Pattern อาจเหมาะสมกว่าหรือไม่

ตัวอย่างที่ 4: ใช้ Action เมื่อมีการบันทึกบทความ

save_post เป็น Hook ที่นักพัฒนาใช้ทำงานหลังการบันทึก Post

ตัวอย่างบันทึก Timestamp ลง Post Meta

function mysite_track_post_save(
    $post_id,
    $post,
    $update
) {
    if ( wp_is_post_revision( $post_id ) ) {
        return;
    }

    if ( wp_is_post_autosave( $post_id ) ) {
        return;
    }

    if ( 'post' !== $post->post_type ) {
        return;
    }

    update_post_meta(
        $post_id,
        '_mysite_last_save',
        current_time( 'mysql' )
    );
}

add_action(
    'save_post',
    'mysite_track_post_save',
    10,
    3
);

ตัวอย่างนี้แสดงการตรวจสอบ Autosave, Revision และ Post Type ก่อนจัดเก็บข้อมูลเพิ่มเติม

อย่างไรก็ตาม save_post สามารถถูกเรียกในหลายสถานการณ์ เช่น การแก้ไขผ่าน Editor หรือการทำงานของระบบอื่น

หากโค้ดรับข้อมูลจากผู้ใช้ ต้องตรวจสอบ Capability, Nonce และ Sanitization ตามบริบทที่เกี่ยวข้อง

การเรียก wp_update_post() ภายใน save_post โดยไม่วางแผนอาจทำให้ Hook ทำงานซ้ำจนเกิด Loop ได้

ตัวอย่างที่ 5: สร้าง Custom Action Hook

นักพัฒนาสามารถสร้าง Action Hook ของตนเองเพื่อเปิดให้ระบบอื่นเชื่อมต่อได้

สมมติว่ามี Custom Plugin ที่ประมวลผลคำสั่งซื้อจากระบบของธุรกิจ

เมื่อกระบวนการสำเร็จ อาจเรียก Hook

do_action(
    'mysite_order_processed',
    $order_id
);

จากนั้นระบบอื่นสามารถลงทะเบียน Callback

function mysite_log_processed_order( $order_id ) {
    error_log(
        'Processed order ID: ' . absint( $order_id )
    );
}

add_action(
    'mysite_order_processed',
    'mysite_log_processed_order',
    10,
    1
);

ตัวอย่างนี้เป็นการสาธิต Custom Action ไม่ใช่ Hook ของ WooCommerce โดยตรง

ในการใช้งานจริงควรจำกัดข้อมูลที่บันทึกใน Log และป้องกันการประมวลผลซ้ำตามความต้องการของระบบ

ตัวอย่างที่ 6: สร้าง Custom Filter Hook

Custom Filter เหมาะกับกรณีที่ต้องการให้ระบบอื่นแก้ไขค่าก่อนนำไปใช้งาน

ตัวอย่างกำหนดชื่อปุ่ม

$button_label = apply_filters(
    'mysite_booking_button_label',
    'จองบริการ'
);

แล้วสร้าง Callback

function mysite_customize_booking_label( $label ) {
    return 'ตรวจสอบคิวว่าง';
}

add_filter(
    'mysite_booking_button_label',
    'mysite_customize_booking_label'
);

เมื่อเรียก apply_filters() จะได้รับข้อความที่ Callback ส่งกลับ

หากต้องแสดงผลบนหน้าเว็บไซต์ ควร Escape ค่าให้เหมาะกับบริบท

echo esc_html( $button_label );

การใช้ Custom Hooks ช่วยให้ Plugin อื่นปรับพฤติกรรมได้โดยไม่จำเป็นต้องแก้โค้ดหลักของระบบ

วิธีใช้ remove_action() และ remove_filter()

บางครั้งนักพัฒนาต้องการยกเลิก Callback ที่เคยถูกลงทะเบียนไว้

WordPress มีฟังก์ชัน

  • remove_action()
  • remove_filter()

ตัวอย่าง remove_action()

function mysite_example_action() {
    echo 'Example';
}

add_action(
    'wp_footer',
    'mysite_example_action',
    10
);

remove_action(
    'wp_footer',
    'mysite_example_action',
    10
);

ในตัวอย่างนี้ Callback ถูกลงทะเบียนแล้วนำออกก่อน Hook ทำงาน จึงไม่ควรถูกเรียกเมื่อถึง wp_footer

การลบ Callback ต้องระบุชื่อ Hook, Callback และ Priority ให้ตรงกับการลงทะเบียนเดิม

ตัวอย่าง remove_filter()

function mysite_example_filter( $title ) {
    return 'New: ' . $title;
}

add_filter(
    'the_title',
    'mysite_example_filter',
    10
);

remove_filter(
    'the_title',
    'mysite_example_filter',
    10
);

หลังนำ Filter ออก Callback นี้จะไม่ถูกใช้กับการเรียก Hook ครั้งถัดไปตามเงื่อนไขที่เกี่ยวข้อง

ทำไม remove_action() บางครั้งไม่ทำงาน?

สาเหตุที่พบบ่อย ได้แก่

  • ใช้ Priority ไม่ตรง
  • ระบุ Callback ไม่ตรง
  • พยายาม Remove ก่อนที่ Callback จะถูก Add
  • Remove หลังจาก Hook ทำงานไปแล้ว
  • Callback ถูกสร้างด้วย Anonymous Function ที่ไม่มี Reference เดิม
  • Callback เป็น Method ของ Object ที่เข้าถึง Instance เดิมไม่ได้

กรณีเหล่านี้ต้องตรวจลำดับการโหลดและโครงสร้าง Callback ให้ถูกต้อง

WordPress Hooks ใช้กับ Class และ OOP ได้ไหม?

ได้ WordPress Hooks สามารถเชื่อมกับ Methods ภายใน Class ได้

ตัวอย่าง

class MySite_Custom_Hooks {

    public function __construct() {
        add_action(
            'init',
            array( $this, 'initialize' )
        );
    }

    public function initialize() {
        // Initialize custom features.
    }
}

new MySite_Custom_Hooks();

ตัวอย่างนี้สร้าง Object แล้วลงทะเบียน Method initialize() กับ Action Hook init

การใช้ Class ช่วยจัดระเบียบโค้ดในโปรเจกต์ขนาดใหญ่ แต่ต้องระวังลำดับการสร้าง Object และการลงทะเบียน Hook

WordPress Hooks ใช้กับ Anonymous Function ได้ไหม?

ได้ PHP รองรับ Anonymous Functions หรือ Closures

ตัวอย่าง

add_action( 'init', function() {
    // Custom initialization.
} );

วิธีนี้เหมาะกับโค้ดสั้น ๆ ที่ไม่ได้ต้องการเรียกใช้ฟังก์ชันซ้ำหลายตำแหน่ง

แต่หากต้องการ Remove Callback ในภายหลัง ควรเก็บ Closure ไว้ในตัวแปรหรือใช้ Named Function เพื่อให้สามารถอ้างอิง Callback เดิมได้

ตัวอย่าง

$callback = function() {
    // Custom action.
};

add_action(
    'init',
    $callback,
    10
);

remove_action(
    'init',
    $callback,
    10
);

WordPress Hooks ควรเขียนไว้ที่ไหน?

สามารถลงทะเบียน Hooks ได้จากหลายตำแหน่ง ขึ้นอยู่กับประเภทงานและโครงสร้างเว็บไซต์

1. Custom Plugin

เหมาะกับฟังก์ชันที่เป็นความสามารถของเว็บไซต์และควรทำงานต่อแม้เปลี่ยน Theme

ตัวอย่างเช่น Custom Business Logic, CPT Registration และ Integrations

2. Child Theme

เหมาะกับโค้ดที่เกี่ยวข้องกับการแสดงผลหรือพฤติกรรมของ Theme

การเขียนลง Child Theme ช่วยลดปัญหาจากการแก้ไฟล์ Parent Theme โดยตรง

3. Must-Use Plugin

เหมาะกับฟังก์ชันที่ผู้ดูแลต้องการให้ระบบโหลดเป็นส่วนหนึ่งของการติดตั้ง WordPress ตามกลไก MU Plugins

แต่ต้องเข้าใจว่าลำดับการโหลดและการจัดการ MU Plugins แตกต่างจาก Plugin ปกติ

4. Code Snippets Plugin

เหมาะกับการทดลองหรือจัดการโค้ดขนาดเล็กผ่านระบบที่รองรับ

อย่างไรก็ตาม หาก Snippet เกิด PHP Fatal Error อาจกระทบการเข้าถึงเว็บไซต์ จึงควรมี Backup และวิธีปิด Snippet ผ่าน Hosting หรือ Recovery Mode

ควรเลือกวิธีไหน?

หากเป็นฟังก์ชันเฉพาะของธุรกิจที่ไม่ควรหายเมื่อเปลี่ยน Theme การทำเป็น Custom Plugin มักเหมาะสมกว่า

หากเป็นการปรับ Layout เฉพาะ Theme อาจใช้ Child Theme

ไม่ควรแก้ไฟล์ WordPress Core โดยตรง เพราะการอัปเดตอาจเขียนทับการเปลี่ยนแปลงและทำให้การบำรุงรักษายุ่งยากขึ้น

WordPress Hooks ใช้กับ Elementor และ JetEngine ได้ไหม?

ได้ Plugin อย่าง Elementor และ JetEngine สามารถเปิดจุดเชื่อมต่อสำหรับนักพัฒนาผ่าน Hooks หรือ APIs ตามความสามารถของแต่ละเวอร์ชัน

ตัวอย่างงานที่อาจเกี่ยวข้อง ได้แก่

  • ปรับข้อมูลก่อนแสดงผล
  • เพิ่ม Business Logic
  • เชื่อมข้อมูลจาก Custom Fields
  • ประมวลผลเหตุการณ์จากฟอร์ม
  • ปรับเงื่อนไขการแสดงผล
  • ทำงานเมื่อข้อมูลถูกสร้างหรืออัปเดต

แต่ควรตรวจสอบเอกสารเฉพาะของแต่ละ Plugin ก่อนใช้ Hook เพราะชื่อ Hook และ Arguments ไม่ได้เป็นมาตรฐานเดียวกันทั้งหมด

ไม่ควรเดาชื่อ Hook จากรูปแบบของ WordPress Core แล้วนำไปใช้กับ Plugin โดยไม่ได้ตรวจเอกสารหรือ Source Code

WordPress Hooks ใช้กับ WooCommerce ได้อย่างไร?

WooCommerce มี Hooks ของตนเองสำหรับขยายความสามารถของระบบร้านค้า

ตัวอย่างประเภทงานที่มักใช้ Hooks ได้แก่

  • ปรับข้อความและข้อมูลสินค้า
  • เพิ่มข้อมูลในหน้าร้าน
  • ทำงานเมื่อสถานะคำสั่งซื้อเปลี่ยน
  • ประมวลผลข้อมูลในกระบวนการสั่งซื้อ
  • เชื่อมระบบภายนอก

อย่างไรก็ตาม WooCommerce มีหลายระบบสำหรับจัดการ Checkout และการแสดงผล เช่น Classic Templates และ Blocks

Hooks ที่รองรับในรูปแบบหนึ่งอาจไม่ทำงานในอีกระบบตามที่คาดหวัง

ก่อนแก้ไข WooCommerce ควรตรวจเอกสาร Developer ของเวอร์ชันและรูปแบบ Checkout ที่ใช้งานจริง

โดยเฉพาะ Hooks ที่เกี่ยวข้องกับข้อมูลคำสั่งซื้อ การชำระเงิน และข้อมูลลูกค้า ต้องออกแบบให้ปลอดภัยและรองรับการทำงานซ้ำ

WordPress Hooks กับ REST API เกี่ยวข้องกันอย่างไร?

WordPress REST API มี Hooks และ Filters ที่ช่วยให้นักพัฒนาปรับพฤติกรรมบางส่วนของระบบได้

ตัวอย่างเช่น rest_api_init มักใช้สำหรับลงทะเบียน Custom REST API Routes

add_action(
    'rest_api_init',
    function() {
        register_rest_route(
            'mysite/v1',
            '/status',
            array(
                'methods'             => 'GET',
                'callback'            => function() {
                    return array(
                        'status' => 'ok',
                    );
                },
                'permission_callback' => '__return_true',
            )
        );
    }
);

ตัวอย่างนี้สร้าง Public Endpoint สำหรับส่งข้อมูลสถานะทั่วไป โดยตั้งใจอนุญาตให้เข้าถึงได้แบบสาธารณะ

หาก Endpoint ส่งข้อมูลส่วนตัวหรือแก้ไขข้อมูล ต้องกำหนด Authentication, Authorization และ Permission Callback ที่เหมาะสม ไม่ควรใช้ __return_true กับข้อมูลที่ต้องป้องกัน

WordPress Hooks ช่วย SEO ได้ไหม?

WordPress Hooks สามารถใช้พัฒนาหรือปรับระบบที่เกี่ยวข้องกับ SEO ได้ แต่ไม่ได้เป็นปัจจัยจัดอันดับโดยตรง

ตัวอย่างงานที่อาจใช้ Hooks ได้แก่

  • ปรับข้อมูล Metadata ผ่าน API ของ SEO Plugin
  • เพิ่ม Structured Data ตามข้อกำหนดที่เหมาะสม
  • ปรับ HTML Output
  • เพิ่ม Breadcrumbs
  • ปรับลิงก์ภายในตามระบบที่ออกแบบไว้
  • จัดการข้อมูลจาก Custom Fields
  • เพิ่มข้อมูลใน Sitemap ผ่าน Hooks ที่รองรับ

แต่การใช้ Hooks ผิดวิธีอาจสร้างปัญหา SEO ได้เช่นกัน

ตัวอย่างเช่น

  • สร้าง Meta Description ซ้ำ
  • เพิ่ม Canonical Tags หลายชุด
  • ปรับ Title ในบริบทที่ไม่ต้องการ
  • สร้าง Structured Data ไม่ถูกต้อง
  • เปลี่ยน Internal Links เป็น URL ที่ผิด
  • เพิ่ม HTML ที่กระทบ Heading Structure

จึงควรตรวจสอบผลลัพธ์ HTML และข้อมูลจาก Search Engine หลังปรับระบบ SEO ด้วย Hooks

WordPress Hooks ทำให้เว็บไซต์ช้าหรือไม่?

Hooks เป็นส่วนหนึ่งของสถาปัตยกรรม WordPress และไม่ได้ทำให้เว็บไซต์ช้าผิดปกติด้วยตัวมันเอง

แต่ Callback ที่ทำงานบน Hook อาจใช้ทรัพยากรจำนวนมากได้

ตัวอย่างเช่น

add_action( 'init', function() {
    // Expensive database operation.
} );

หากโค้ดภายในทำ Database Query ขนาดใหญ่ทุกครั้งที่ Hook init ถูกเรียก อาจเพิ่มเวลาในการประมวลผลของ Requests

ปัญหาประสิทธิภาพที่ควรระวัง

  • Database Queries ใน Hook ที่ทำงานบ่อย
  • HTTP Requests ไปยัง API ภายนอกแบบ Blocking
  • การประมวลผลข้อมูลจำนวนมาก
  • การเรียก Callback ซ้ำโดยไม่จำเป็น
  • การเพิ่ม Filters หลายชั้นที่ทำงานหนัก
  • การใช้ Hooks โดยไม่ตรวจบริบทของ Request

แนวทางที่เหมาะสมคือใช้ Hook ให้ถูกจังหวะ ลดงานที่ไม่จำเป็น และใช้ Cache หรือ Background Processing เมื่อเหมาะกับประเภทงาน

ไม่ควรย้ายการทำงานที่ต้องใช้เวลานานมาอยู่ในทุก Request หากไม่มีเหตุผลจำเป็น

ข้อผิดพลาดที่พบบ่อยในการใช้ WordPress Hooks

1. ใช้ Action แทน Filter

หากต้องการปรับค่าที่ส่งกลับไปยังระบบ ควรใช้ Filter ที่ออกแบบมาสำหรับข้อมูลนั้น

2. ลืม Return Value ใน Filter

อาจทำให้ข้อมูลเดิมถูกแทนที่ด้วยค่าที่ไม่ถูกต้อง เช่น null

3. ใช้ Hook ผิดจังหวะ

บางฟังก์ชันต้องถูกเรียกหลังจาก WordPress หรือ Plugin โหลดข้อมูลที่จำเป็นแล้ว

4. ตั้ง Priority โดยไม่ตรวจสอบ

อาจทำให้ Callback ทำงานก่อนหรือหลังส่วนที่จำเป็นอย่างไม่เหมาะสม

5. รับ Arguments ไม่ครบตามที่ใช้

หาก Callback ต้องใช้ Arguments หลายตัว ต้องตั้งค่า accepted_args ให้เหมาะสม

6. ใช้ Filter โดยไม่ตรวจชนิดข้อมูล

อาจทำให้ Plugin อื่นที่รอรับ Array หรือ Object ได้รับ String หรือ null แทน

7. ใช้ save_post แล้วเกิด Loop

หากบันทึก Post ซ้ำภายใน Hook โดยไม่มีการจัดการที่เหมาะสม อาจเกิดการเรียก Hook ต่อเนื่อง

8. เพิ่ม HTML โดยไม่ Escape ข้อมูล

อาจสร้างปัญหาความปลอดภัย เช่น Cross-Site Scripting หากแสดงข้อมูลที่มาจากผู้ใช้โดยไม่ตรวจสอบ

9. แก้ WordPress Core

การแก้ Core Files โดยตรงทำให้การอัปเดตและบำรุงรักษายากขึ้น

10. ใช้ Hook กับ Production โดยไม่ทดสอบ

หากโค้ดเกิด Fatal Error อาจทำให้เว็บไซต์หรือ Dashboard ไม่สามารถเข้าถึงได้

วิธี Debug WordPress Hooks

หากเพิ่ม Hook แล้วไม่ทำงาน ควรตรวจสอบตามลำดับ

ตรวจชื่อ Hook

ยืนยันว่า Hook มีอยู่จริงและสะกดถูกต้อง

ตรวจว่า Hook ถูกเรียกหรือไม่

บาง Hook ทำงานเฉพาะในบริบท เช่น Frontend, Admin หรือ REST API

ตรวจ Callback

ตรวจว่าฟังก์ชันมีอยู่และสามารถเรียกได้

ตรวจ Priority

หากโค้ดต้องทำงานก่อนหรือหลัง Callback อื่น ต้องตรวจลำดับให้เหมาะสม

ตรวจ Arguments

ตรวจว่ารับค่าตรงกับที่ Hook ส่งมา

ตรวจ Error Logs

เปิด WordPress Debug Log อย่างเหมาะสมใน Staging เพื่อค้นหา PHP Warnings และ Fatal Errors

ตรวจ Plugin Conflicts

อาจมี Plugin หรือ Theme อื่นเพิ่มหรือนำ Callback ออก หรือเปลี่ยนผลลัพธ์ผ่าน Filter เดียวกัน

ใช้ did_action() เมื่อต้องการตรวจจำนวนครั้ง

ตัวอย่าง

$count = did_action( 'init' );

ฟังก์ชันนี้คืนจำนวนครั้งที่ Action Hook ดังกล่าวถูกเรียกระหว่างกระบวนการทำงานปัจจุบัน

แต่ไม่ใช่เครื่องมือยืนยันว่า Callback เฉพาะตัวทำงานสำเร็จ

ใช้ has_action() และ has_filter()

ใช้ตรวจสอบว่ามี Callback ที่ลงทะเบียนกับ Hook หรือไม่ ตามรูปแบบการเรียกและพารามิเตอร์ที่รองรับ

เครื่องมือเหล่านี้ช่วย Debug การลงทะเบียน Hooks แต่ไม่ได้แทนที่การตรวจสอบผลลัพธ์จริง

WordPress Hooks กับ JavaScript Hooks ต่างกันอย่างไร?

WordPress มีระบบ Hooks สำหรับ PHP และมี Hooks API สำหรับ JavaScript ซึ่งใช้ในระบบอย่าง Block Editor

สำหรับ PHP มักใช้

add_action();
add_filter();

ส่วน JavaScript Hooks API สามารถใช้ผ่านแพ็กเกจ @wordpress/hooks

ตัวอย่างการลงทะเบียน JavaScript Filter

import { addFilter, applyFilters } from '@wordpress/hooks';

addFilter(
    'mysite.exampleLabel',
    'mysite/custom-label',
    (label) => `${label} ใหม่`
);

const result = applyFilters(
    'mysite.exampleLabel',
    'บทความ'
);

ผลลัพธ์ของ result คือข้อความ

บทความ ใหม่

ตัวอย่างนี้เป็น Custom JavaScript Hook และต้องใช้ในสภาพแวดล้อม Build หรือระบบโหลด Script ที่รองรับ ES Modules และ Dependencies ที่เกี่ยวข้อง

ไม่ควรนำ JavaScript ตัวอย่างนี้ไปวางใน PHP Snippet โดยตรง

WordPress Hooks เหมาะกับใคร?

WordPress Developers

ใช้สร้าง Plugin และขยายความสามารถโดยไม่แก้ Core Files

Theme Developers

ใช้ปรับการแสดงผล โหลด Assets และเชื่อมฟังก์ชันกับ Theme

WooCommerce Developers

ใช้ขยายระบบสินค้า คำสั่งซื้อ และส่วนประกอบของร้านค้า

SEO Developers

ใช้ปรับระบบ Metadata, Structured Data และการแสดงผลผ่าน APIs ที่รองรับ

Website Administrators

ผู้ดูแลเว็บไซต์ที่มีความรู้ PHP สามารถใช้ Hooks เพื่อปรับฟังก์ชันเฉพาะทาง โดยควรทดสอบก่อนใช้งานจริง

ผู้เริ่มต้นที่ยังไม่คุ้นเคยกับ PHP ควรศึกษา Functions, Variables, Arrays, Callbacks และการจัดการ Error ก่อนพัฒนา Hooks ที่เกี่ยวข้องกับข้อมูลสำคัญ

WordPress Hooks Checklist ก่อนนำโค้ดไปใช้จริง

  • ตรวจว่าเป็น Action หรือ Filter
  • ตรวจชื่อ Hook จากเอกสารทางการ
  • ตรวจจังหวะการทำงานของ Hook
  • ตรวจ Arguments ที่ Hook ส่งมา
  • กำหนด Priority อย่างเหมาะสม
  • ตั้งค่า accepted_args ให้ตรงกับ Callback
  • ตรวจ Return Value ของ Filter
  • ตรวจชนิดข้อมูลที่รับและส่งกลับ
  • ใช้ชื่อ Function ที่ไม่ชนกับระบบอื่น
  • ตรวจ Security และ User Capabilities
  • ใช้ Sanitization กับข้อมูลขาเข้า
  • ใช้ Escaping กับข้อมูลขาออก
  • ระวัง Recursive Hooks และ Infinite Loops
  • ลด Database Queries ที่ไม่จำเป็น
  • ไม่แก้ไข WordPress Core โดยตรง
  • สำรองข้อมูลก่อนแก้ระบบสำคัญ
  • ทดสอบบน Staging
  • ตรวจ Error Logs
  • ทดสอบ Plugin และ Theme Compatibility
  • บันทึกโค้ดและผลการทดสอบ

คำถามที่พบบ่อยเกี่ยวกับ WordPress Hooks (FAQ)

WordPress Hooks คืออะไร?

WordPress Hooks คือระบบที่ช่วยให้นักพัฒนาสามารถเพิ่มหรือปรับเปลี่ยนการทำงานของ WordPress ผ่านจุดเชื่อมต่อที่กำหนด โดยไม่จำเป็นต้องแก้ไฟล์ Core โดยตรง

WordPress Hooks มีกี่ประเภท?

มี 2 ประเภทหลัก ได้แก่ Action Hooks และ Filter Hooks

Action Hooks กับ Filter Hooks ต่างกันอย่างไร?

Action Hooks ใช้เรียก Callback ให้ทำงานเมื่อถึงจุดที่กำหนด ส่วน Filter Hooks ใช้รับข้อมูล ปรับค่า และคืนค่ากลับไปให้ระบบใช้งาน

add_action() คืออะไร?

เป็นฟังก์ชันที่ใช้ลงทะเบียน Callback ให้ทำงานเมื่อ Action Hook ที่ระบุถูกเรียก

add_filter() คืออะไร?

เป็นฟังก์ชันที่ใช้ลงทะเบียน Callback สำหรับปรับเปลี่ยนข้อมูลที่ส่งผ่าน Filter Hook

do_action() คืออะไร?

เป็นฟังก์ชันที่ใช้เรียก Action Hook และกระตุ้นให้ Callback ที่ลงทะเบียนไว้ทำงาน

apply_filters() คืออะไร?

เป็นฟังก์ชันที่ส่งข้อมูลผ่าน Filter Callbacks แล้วรับค่าที่ผ่านการปรับเปลี่ยนกลับมา

WordPress Hook Priority คืออะไร?

Priority คือค่ากำหนดลำดับการทำงานของ Callbacks ภายใน Hook เดียวกัน โดยค่าต่ำกว่าจะทำงานก่อน และค่าเริ่มต้นคือ 10

accepted_args ใช้ทำอะไร?

ใช้กำหนดจำนวน Arguments สูงสุดที่ Callback รับจาก Hook ตามข้อมูลที่ Hook ส่งมา

Filter ต้อง Return Value ทุกครั้งไหม?

ควรคืนค่าที่เหมาะสมตามสัญญาของ Filter เพราะ WordPress ใช้ค่าที่ส่งกลับไปประมวลผลต่อ

สามารถสร้าง Custom Hooks ได้ไหม?

ได้ สามารถใช้ do_action() สำหรับ Custom Actions และ apply_filters() สำหรับ Custom Filters

WordPress Hooks เขียนไว้ใน functions.php ได้ไหม?

ได้ โดยเฉพาะงานที่สัมพันธ์กับ Theme แต่ฟังก์ชันที่ควรอยู่ต่อเมื่อเปลี่ยน Theme มักเหมาะกับ Custom Plugin มากกว่า

WordPress Hooks ใช้กับ Elementor ได้ไหม?

ได้ตาม Hooks และ APIs ที่ Elementor รองรับ แต่ต้องตรวจสอบเอกสารของเวอร์ชันที่ใช้งานจริง

WordPress Hooks ใช้กับ WooCommerce ได้ไหม?

ได้ WooCommerce มี Hooks สำหรับขยายระบบหลายส่วน แต่ต้องตรวจสอบ Compatibility โดยเฉพาะเมื่อใช้ WooCommerce Blocks หรือ Checkout รูปแบบใหม่

WordPress Hooks ส่งผลต่อ SEO หรือไม่?

Hooks สามารถใช้พัฒนาระบบที่เกี่ยวข้องกับ SEO ได้ แต่ไม่ได้เพิ่มอันดับโดยตรง และหากใช้ผิดอาจทำให้ Metadata หรือ HTML ทำงานไม่ถูกต้อง

WordPress Hooks ทำให้เว็บช้าหรือไม่?

Hooks ไม่ได้ทำให้เว็บไซต์ช้าโดยตัวมันเอง แต่ Callback ที่มี Query หนักหรือประมวลผลมากเกินไปอาจเพิ่มเวลาในการทำงาน

remove_action() และ remove_filter() คืออะไร?

เป็นฟังก์ชันสำหรับนำ Callback ออกจาก Action หรือ Filter Hook โดยต้องระบุ Callback และ Priority ให้ตรงกับการลงทะเบียนเดิม

WordPress Hooks กับ REST API ต่างกันอย่างไร?

Hooks เป็นกลไกเชื่อมต่อและปรับพฤติกรรมภายในระบบ ส่วน REST API เป็นช่องทางติดต่อข้อมูลและความสามารถของ WordPress ผ่าน HTTP ทั้งสองสามารถทำงานร่วมกันได้

สรุป WordPress Hooks ควรใช้ Actions หรือ Filters?

WordPress Hooks เป็นพื้นฐานสำคัญในการพัฒนาและปรับแต่งเว็บไซต์ WordPress เพราะช่วยให้สามารถเชื่อม Custom Code เข้ากับกระบวนการทำงานของระบบโดยไม่ต้องแก้ไฟล์ Core โดยตรง

หากต้องการให้ระบบทำงานบางอย่างเมื่อเกิดเหตุการณ์ เช่น ลงทะเบียน Custom Post Type โหลด CSS หรือประมวลผลหลังบันทึกบทความ ควรพิจารณา Action Hook

แต่หากต้องการปรับข้อมูลที่ส่งผ่าน เช่น Title, Content, CSS Classes หรือค่าที่ Plugin เปิดให้เปลี่ยน ควรพิจารณา Filter Hook

นักพัฒนาควรเข้าใจการทำงานของ add_action(), add_filter(), do_action() และ apply_filters() รวมถึง Priority, Arguments และ Return Values ก่อนนำไปใช้กับเว็บไซต์จริง

การเลือก Hook ที่ถูกต้องและเขียน Callback อย่างปลอดภัยจะช่วยให้โค้ดดูแลรักษาได้ง่าย ลดความขัดแย้งระหว่าง Plugin และรองรับการพัฒนาฟังก์ชันเพิ่มเติมในอนาคต

หลักการจำง่ายที่สุดคือ Action ใช้สั่งให้ทำงาน ส่วน Filter ใช้ปรับข้อมูลแล้วส่งค่ากลับ และทั้งสองควรใช้งานผ่านจุดเชื่อมต่อที่ WordPress หรือ Plugin รองรับอย่างเป็นทางการ


แหล่งข้อมูลอ้างอิง

  1. WordPress Developer Resources — Hooks
    https://developer.wordpress.org/plugins/hooks/
  2. WordPress Developer Resources — Actions
    https://developer.wordpress.org/plugins/hooks/actions/
  3. WordPress Developer Resources — Filters
    https://developer.wordpress.org/plugins/hooks/filters/
  4. WordPress Developer Resources — Custom Hooks
    https://developer.wordpress.org/plugins/hooks/custom-hooks/
  5. WordPress Developer Resources — add_action()
    https://developer.wordpress.org/reference/functions/add_action/
  6. WordPress Developer Resources — add_filter()
    https://developer.wordpress.org/reference/functions/add_filter/
  7. WordPress Developer Resources — do_action()
    https://developer.wordpress.org/reference/functions/do_action/
  8. WordPress Developer Resources — apply_filters()
    https://developer.wordpress.org/reference/functions/apply_filters/
  9. WordPress Developer Resources — remove_action()
    https://developer.wordpress.org/reference/functions/remove_action/
  10. WordPress Developer Resources — remove_filter()
    https://developer.wordpress.org/reference/functions/remove_filter/
  11. WordPress Block Editor Handbook — JavaScript Hooks
    https://developer.wordpress.org/block-editor/reference-guides/packages/packages-hooks/

บทความ ที่เกี่ยวข้อง

nyepi day celebration indonesia Web H
WordPress Hooks คืออะไร? Actions และ Filters ต่างก...
WordPress Hooks คือระบบที่ช่วยให้นักพัฒนาสามารถเพิ่ม ปรับเปลี่ยน หรือขยายการทำงา...
nyepi day celebration indonesia Web H
WordPress Child Theme คืออะไร? จำเป็นต้องใช้เมื่อไ...
WordPress Child Theme คือธีมลูกที่สืบทอดรูปแบบการแสดงผลและความสามารถจากธีมหลัก (...
nyepi day celebration indonesia Web H
WordPress Block Theme กับ Classic Theme ต่างกันอย่...
WordPress Block Theme กับ Classic Theme แตกต่างกันที่วิธีสร้างและจัดการโครงสร้าง...
nyepi day celebration indonesia Web H
WordPress Query Loop คืออะไร? วิธีแสดงบทความแบบกำห...
WordPress Query Loop คือบล็อกของ Gutenberg ที่ใช้ดึงและแสดงบทความ หน้าเว็บไซต์ ห...
nyepi day celebration indonesia Web H
WordPress Autoload Options คืออะไร? ทำไมทำให้เว็บไ...
WordPress Autoload Options คือข้อมูลการตั้งค่าภายในฐานข้อมูล WordPress ที่ระบบกำ...
nyepi day celebration indonesia Web H
WP-CLI คืออะไร? วิธีจัดการ WordPress ผ่าน Command ...
WP-CLI คือเครื่องมือ Command Line Interface สำหรับจัดการเว็บไซต์ WordPress ผ่านค...
nyepi day celebration indonesia Web H
WordPress Transients API คืออะไร? ช่วย Cache ข้อมู...
WordPress Transients API คือระบบสำหรับจัดเก็บข้อมูลชั่วคราว (Temporary Cached Da...
พร้อมที่จะเริ่มต้นหรือยัง?