ฉันเป็นสื่อกลางใน PHP เพื่อขัดเกลาทักษะของฉันฉันเริ่มเรียนรู้ Drupal 7 ในขณะที่เรียนรู้แนวคิดสถาปัตยกรรมของ Drupal คำว่าhooksและbootstrappingทำให้ฉันงงมาก ฉันอ่านหนังสือ "Pro Drupal development" และเอกสารบางอย่างเกี่ยวกับ drupal.org แต่มันก็เป็นขั้นสูงสำหรับฉันที่จะเรียนรู้วิธี hooks ทำงานใน Drupal เพื่อแสดงหน้าเว็บ
ทุกคนสามารถบอกฉันได้ไหมว่า hooks อยู่ในคำง่าย ๆ ?
คำตอบ:
คำตอบอื่น ๆ นั้นยอดเยี่ยมถูกต้องละเอียด แต่ฉันไม่แน่ใจว่าพวกเขาเป็น "คำง่าย ๆ " ที่อธิบายถึงกระดูกที่เปลือยเปล่าของแนวคิดที่ผู้ถามกำลังมองหา
ฉันคิดว่า hooks เป็นจุดที่โค้ดหยุดและตะโกนว่า " ใครมีอะไรเพิ่มที่นี่? " โมดูลใด ๆ สามารถมีฟังก์ชั่นที่ตอบกลับสิ่งนี้และได้รับการทริกเกอร์ด้วยข้อมูลที่เหมาะสมผ่านไปยังจุดนั้นในรหัส
ตัวอย่างที่ตรงไปตรงมาดีคือhook_node_delete () โมดูลใด ๆ สามารถใช้เพื่อทำให้สิ่งต่าง ๆ เกิดขึ้นทุกครั้งที่มีการลบโหนด เอกสารบอกคุณว่า hook นี้ผ่านโมดูลวัตถุของโหนดที่ถูกลบเพื่อทำงานกับและแสดงข้อมูลที่เป็นประโยชน์อื่น ๆ เช่นเกี่ยวกับเวลาที่แน่นอนของเมื่อมันถูกเรียก (เช่นว่ามันเป็นก่อนที่ข้อมูลโหนดจะถูกลบออกจากฐานข้อมูล) และในรหัสของ Drupal จะมีการเรียก hook (ซึ่งอาจมากกว่าหนึ่งแห่ง)
คุณสามารถสำรวจสิ่งที่อยู่ตะขอและหาสิ่งที่ข้อมูลจะถูกส่งผ่านไปยังพวกเขาโดยการสำรวจสิ่งที่เริ่มต้นด้วย "hook_" ในAPI ของ Drupal
Hooks ทำงานโดยระเบียบชื่อ: ใช้hook_node_deleteเป็นตัวอย่างของเราเมื่อกระบวนการลบโหนดมาถึงจุดที่ hook ถูกเรียกใช้สำหรับทุกโมดูลที่มีฟังก์ชันเช่นนี้[modulename]_node_delete()โดยที่ hook คำในชื่อ hook ถูกแทนที่ด้วยชื่อโมดูล (เช่นmy_amazing_module_node_delete()) ฟังก์ชั่นเหล่านั้นถูกเรียก
ทำไม? ดังนั้นโมดูลใด ๆ สามารถทำสิ่งใดก็ได้ที่จุดสำคัญเหล่านี้: ตัวอย่างเช่นคุณสามารถดูโหนดที่ถูกลบและทำสิ่งต่าง ๆ ถ้ามันตรงตามเงื่อนไขที่แน่นอน (พูดส่งอีเมลผู้ดูแลระบบหรือเปิดใช้กระบวนการที่ยาวนาน)
hooks บางตัวช่วยให้คุณสามารถแก้ไขสิ่งต่าง ๆ ที่สร้างขึ้นก่อนที่จะถูกประมวลผล ตัวอย่างเช่นhook_menu_alter ()ส่งรายการเมนูปัจจุบันที่ระบบสร้างขึ้นให้คุณ โมดูลใด ๆ สามารถกำหนดฟังก์ชั่น some_modulename_menu_alter () และดูที่พวกเขาเลือกที่จะเปลี่ยนแปลงพวกเขา (ลบบางคนเพิ่มบางคนเรียงลำดับพวกเขา ... ) และผ่านเมนูการเปลี่ยนแปลงใหม่กลับมา
มันเรียบง่ายมีประสิทธิภาพมากและเป็นหัวใจสำคัญของ Drupal ที่ทำงานเป็นระบบโมดูลาร์ การติดตั้ง hooks เป็นหัวใจของโมดูลส่วนใหญ่ของ Drupal
เมื่อมองดูโค้ดของโมดูล Drupal คุณสามารถมองเห็นว่าฟังก์ชั่นใดมาจาก hooks (ตรงข้ามกับฟังก์ชั่นที่เรียกง่ายๆจากโค้ดโมดูลในตัวมันเอง) เนื่องจากชุมชน Drupal บังคับใช้การประชุมโดยแต่ละ hook มี แสดงความคิดเห็นต่อหน้ามันเช่นนี้ (โปรดทราบบิต "Implements hook _... "):
/**
* Implements hook_some_hook().
*
* Some descriptive summary of what this does
*/
function my_amazing_module_some_hook() {บางโมดูลที่ทำหน้าที่เป็น API กำหนด hooks ของตัวเอง ตัวอย่างเช่นViewsกำหนด hooks จำนวนมากที่อนุญาตให้คุณเพิ่มอ่านและแก้ไขข้อมูลที่จุดต่าง ๆ ในกระบวนการสร้างหรือแสดงมุมมอง คุณสามารถค้นหาข้อมูลเกี่ยวกับ hooks ที่สร้างขึ้นในโมดูลที่กำหนดเองจากสองแห่ง (สมมติว่าโมดูลเป็นไปตามอนุสัญญา ฯลฯ ):
modulename.api.phpไฟล์ในโฟลเดอร์โมดูลการบู๊ตคืออย่างที่คนอื่นอธิบายโดยทั่วไปแล้วการบูท - ฉันจะไม่ทำซ้ำคำอธิบายที่ชัดเจนอื่น ๆ
Hooks เป็นการนำไปปฏิบัติของVisitorและObserverลวดลายเป็นส่วนใหญ่
หนึ่งในการติดตั้ง hooks ที่พบมากที่สุดคือhook_menuซึ่งอนุญาตให้โมดูลลงทะเบียนพา ธ ใหม่ภายในระบบ Drupal
function my_module_menu() {
return array('myawesomefrontpage' => array(
'page callback' => 'function_that_will_render_frontpage'
));
}รูปแบบที่บ่อยมากใน Drupal คือการมี[DATATYPE]_infoตะขอและ[DATATYPE]_info_alterตะขอ หากคุณต้องการสร้างประเภทฟิลด์ใหม่คุณจะใช้field_info -hook ที่เกี่ยวข้องและหากคุณต้องการจัดการกับฟิลด์ที่มีอยู่คุณจะใช้field_info_alter -hook ที่เกี่ยวข้อง
แก้ไข:ตามที่ Chx ชี้ให้เห็นในความคิดเห็นรูปแบบของผู้สังเกตการณ์นั้นเป็นเชิงวัตถุซึ่ง Drupal 7 ยังคงเป็นส่วนใหญ่ไม่ใช่ อย่างไรก็ตามมีหน้าวิกิ, การเขียนโปรแกรม Drupal จากมุมมองเชิงวัตถุ (สร้างโดย JonBob เมื่อวันที่ 4 เมษายน 2548) ซึ่งอธิบายว่า Drupal ใช้รูปแบบโค้ดเชิงวัตถุอย่างไร เป็นเรื่องที่น่าสนใจที่จะกล่าวถึงผู้สังเกตการณ์ แต่ไม่ใช่ผู้เยี่ยมชม
หมายเหตุเกี่ยวกับ Drupal 8นี้ยังค่อนข้างเร็วและอาจมีการเปลี่ยนแปลง แต่ฉันต้องการเพิ่มในขณะที่ hooks มีบางครั้งมาตรฐาน de-พฤตินัยในการเพิ่มฟังก์ชันการทำงานให้กับ Drupal แนวคิดของปลั๊กอินจะมองเห็นได้ชัดเจนขึ้น ใน Drupal 8 และจะให้วิธีการใหม่ในการโต้ตอบกับ Core ที่เกี่ยวข้องกับปัญหาและเอกสาร
ในแง่ของคนธรรมดา hooks เป็นประเภทของสะพานที่ให้วิธีการในการโต้ตอบกับโมดูลเปลี่ยนโครงสร้างและข้อมูลของกันและกันให้ข้อมูลใหม่เป็นต้น
ในกรณีส่วนใหญ่คำhook_ในชื่อฟังก์ชั่นจะถูกแทนที่ด้วยชื่อของโมดูลของคุณและที่มีวิธีสำหรับโมดูลของคุณที่จะแตะในการดำเนินงานของโมดูลอื่น ตัวอย่างเช่นโมดูลหลัก drupal เรียกว่า "node" เรียกใช้ hooks ต่าง ๆ หนึ่งในนั้นคือhook_node_updateสิ่งที่ถูกเรียกใช้ทุกครั้งที่มีการอัปเดตโหนดที่มีอยู่ เมื่อตะขอนี้ถูกเรียกใช้โมดูลของคุณ (บอกว่าเราเรียกมันว่าmymodule) การใช้งานของhook_node_updateเรียกว่าซึ่งในกรณีนี้จะเป็นฟังก์ชั่นในไฟล์. โมดูลโมดูลของคุณที่เรียกว่าmymodule_node_update(เห็นได้ชัดว่าฟังก์ชั่นนี้สามารถอยู่ในไฟล์ใด ๆ มันรวมอยู่ในไฟล์. mod ด้วยเช่นกัน) เบ็ดนี้จะถูกส่งผ่านพารามิเตอร์ที่จำเป็น (ตัวแปร) ซึ่งมันสามารถใช้แก้ไขและ / หรือกลับไปที่ฟังก์ชั่นที่เรียกใช้ตะขอ
เมื่อฉันเริ่มเรียนรู้ Drupal ครั้งแรกฉันอยู่ในเรือลำเดียวกันกับคุณตอนนี้มันค่อนข้างยากที่จะเข้าใจในตอนแรก แต่เมื่อคุณได้รับมันมันช่างง่ายและใช้งานง่าย โชคดี.
หนึ่งในนักพัฒนาหลักเขียนขึ้นบทความที่ผ่านมาในขณะที่เรียกว่า"การเขียนโปรแกรม Drupal จากมุมมองเชิงวัตถุ" มันเป็นงานที่ดีที่จะอธิบายว่าตะขอสามารถใช้เป็นรูปแบบการออกแบบทั่วไปได้อย่างไร คำอธิบายที่ดีที่สุดของ hooks มาจากบทความ:
ระบบ hook ของ Drupal เป็นพื้นฐานสำหรับอินเทอร์เฟซที่เป็นนามธรรม hooks กำหนดการดำเนินการที่สามารถดำเนินการในหรือโดยโมดูล หากโมดูลใช้เบ็ดมันจะเข้าสู่สัญญาเพื่อดำเนินงานโดยเฉพาะหรือส่งคืนข้อมูลบางประเภทเมื่อมีการเรียกใช้ตะขอ รหัสการโทรไม่จำเป็นต้องรู้อะไรเกี่ยวกับโมดูลหรือวิธีการนำ hook มาใช้เพื่อให้ได้งานที่มีประโยชน์โดยการเรียกใช้ hook
Bootstrap เป็นกระบวนการที่ Drupal ดำเนินการเพื่อสร้างหน้าเว็บโดยทั่ว ๆ ไปจะใช้งานคอร์หลัก, ธีมและโค้ดโมดูลตามลำดับ
มันเป็นพื้นฐานที่ Drupal เริ่มต้นขึ้นและเตรียมพร้อมที่จะทำหน้าที่เป็น CMS
มันฉลาดในการที่เราสามารถใส่ hooks ได้ทุกที่ในโมดูลและธีมของเราและกระบวนการบู๊ตสแตรปทำให้แน่ใจว่าพวกเขาจะทำงานในจุดที่ถูกต้อง
ตัวอย่างเช่นถ้าคุณใช้ 'hook_form_alter' เพื่อเพิ่มกล่องกาเครื่องหมายที่กำหนดเองให้กับฟอร์ม Bootstrap ของ Drupal จะตรวจสอบให้แน่ใจว่ามันรันโค้ดนั้นก่อนที่มันจะแสดงผลแบบฟอร์มของคุณ
ปัญหาหนึ่งของ bootstrap คือกระบวนการทั้งหมดใช้เวลาในการรันแม้ว่าคุณจะส่งคืนข้อมูลจำนวนเล็กน้อยเท่านั้น เมื่อใช้ Drupal กับโมดูลบริการเป็น API และส่งคืนการตอบสนอง XHTML หรือ JSON ขนาดเล็กจำนวนมากการเรียกใช้ผ่าน bootstrap ทั้งหมดนั้นไม่ค่อยมีประสิทธิภาพ คนฉลาดบางคนกำลังมองหาวิธีที่ชาญฉลาดสำหรับ Drupal 8
แต่สำหรับการแสดงผลหน้า Drupal ปกติกระบวนการ bootstrap ใช้งานได้ดีมันใช้ระบบแคชของ Drupals เพื่อเร่งความเร็วและช่วยให้คุณควบคุมทุกส่วนของเว็บไซต์ได้อย่างสมบูรณ์ หากคุณพบว่าเว็บไซต์ของคุณช้าคุณสามารถใช้บางอย่างเช่น APC หรือ MemCached เพื่อช่วยเร่งความเร็วของสิ่งต่างๆ
ฉันหวังว่าคำตอบของฉันจะถูกต้องและอธิบายสิ่งต่าง ๆ เพียงเพื่อคุณฉันไม่ชำนาญ แต่ฉันคิดว่านั่นเป็นวิธีการทำงาน
Bootstrapเป็นกระบวนการระหว่างที่ Drupal เริ่มต้นเอง; กระบวนการรวมถึง:
$_SERVERinit_set()การดำเนินการบางอย่างที่ฉันอธิบายมีเฉพาะสำหรับ Drupal 7 หรือสูงกว่า แต่การดำเนินการส่วนใหญ่นั้นเป็นอิสระจาก Drupal
hook เป็นฟังก์ชัน PHP ที่สามารถเรียกได้จาก Drupal หรือโมดูลของบุคคลที่สามเมื่อจำเป็นในการทำงาน แทนที่จะมีรายการฟังก์ชั่นที่ต้องนำหน้ารายการจะสร้างการตรวจสอบโมดูลที่เปิดใช้งานและฟังก์ชั่นที่ใช้
ตัวอย่างเช่น Drupal ใช้hook_node_update(); เมื่อโหนดถูกบันทึกด้วยnode_save ()รหัสต่อไปนี้จะถูกดำเนินการ
// Call the node specific callback (if any). This can be
// node_invoke($node, 'insert') or
// node_invoke($node, 'update').
node_invoke($node, $op);สิ่งใดnode_invoke ()ทำสิ่งต่อไปนี้:
$nodeเป็นพารามิเตอร์Hooks สามารถบันทึกข้อมูลของตนเองในฐานข้อมูลหรือแก้ไขค่าที่ส่งคืนจากฟังก์ชัน กรณีสุดท้ายคือตัวอย่างเช่นสิ่งที่เกิดขึ้นกับhook_form_alter ()ซึ่งจะเปลี่ยนแปลงค่าของการ$formส่งผ่านเป็นอ้างอิงถึงdrupal_prepare_form ()
โดยทั่วไปตะขอของ Drupal จะถูกเรียกใช้โดยใช้ฟังก์ชั่นที่สาม:
drupal_alter()เป็นฟังก์ชั่นที่ใช้ในการเรียกใช้ตะขอที่เฉพาะเจาะจงที่มีวัตถุประสงค์เพื่อแก้ไขข้อมูลที่ส่งผ่านไปพวกเขาเป็นข้อมูลอ้างอิงเช่นhook_form_alter () , hook_hook_info_alter ()และhook_tokens_alter ()
มีฟังก์ชั่นอื่น ๆ ที่ใช้ในการเรียกใช้ hooks เช่นnode_invoke()แต่ฟังก์ชั่นเหล่านั้นใช้ฟังก์ชั่นที่ฉันระบุไว้ก่อนหน้านี้
ตะขอเป็นจุดสำคัญและmodule_invoke_allเป็นผู้ประกอบ (อนิจจาเรายังไม่ชัดเจนในการนำไปใช้ เท่าที่ฉันทราบ Drupal เป็นระบบเดียวที่ใช้AOPกับฟังก์ชั่น PHP
ดูคำอธิบายเพิ่มเติมเกี่ยวกับวิธีการทำงานของ AOP ใน Drupal
หากคุณต้องการเห็น hooks Drupal ให้คุณโทรไปที่api.drupal.orgแท็บไปที่ช่องค้นหาแล้วพิมพ์ 'hook_' นี่จะให้รายการใหญ่ของตะขอส่วนใหญ่ที่ Drupal กำหนด ทำสิ่งเดียวกันสำหรับ '_alter' และดูมากกว่านี้
หน้าNode API hooks เสนอรายการตามลำดับเวลาของ hooks ทั้งหมดที่เรียกใช้ในระหว่างการดำเนินการของโหนด คุณสามารถเห็นโมดูล Node และระบบ Entity และ Field ที่ให้ผลัดกันเรียกใช้ hooks
ตัวอย่างเช่นหากคุณเลื่อนลงและดูที่ส่วนสำหรับnode_load(): โมดูลโหนดจะให้ hook_load () ของคุณแล้วส่งการควบคุมไปยังระบบเอนทิตีที่โหลดบางฟิลด์ มีพื้นที่ทั้งหมดของตะขอฟิลด์ไม่ได้จดทะเบียนมีและจากนั้นเมื่อที่มากกว่าระบบของกิจการจะเรียกก่อนที่จะผ่านการควบคุมกลับไปยังโหนดซึ่งเรียกhook_entity_load()hook_node_load()
สิ่งนี้จะช่วยให้โค้ดของคุณมีโอกาสที่จะดำเนินการกับโหนดที่มีปัญหาในขณะที่โหลดเป็นชิ้น ๆ เรียนรู้เกี่ยวกับตะขอเหล่านี้และเมื่อใดและทำไมพวกเขาถึงถูกเรียกว่าเป็นส่วนหนึ่งของการผจญภัยของการเข้ารหัสของ Drupal :-)
ระบบอื่นมีตะขอด้วย เช่นและhook_init() hook_boot()สิ่งนี้จะนำไปสู่ส่วนบู๊ตของคำถามของคุณ hook_boot()ถูกเรียกใช้โดย Drupal ก่อนที่ระบบแคชจะโหลด ดังนั้นถ้าโมดูลของคุณต้องการที่จะทำบางสิ่งบางอย่างก่อนที่จะ Drupal hook_boot()ได้เริ่มต้นขึ้นจริงๆและคุณต้องการรหัสของคุณทำงานโดยไม่คำนึงถึงแคชแล้วคุณต้องการใช้ hook_init()มิฉะนั้นถ้าคุณจะดูแลหน้าเกี่ยวกับการที่ไม่ได้เก็บไว้ที่คุณต้องการใช้
สิ่งนี้จะช่วยให้คุณมีทางเลือกในการติดตั้งบางอย่างในช่วงต้นของกระบวนการโหลดก่อนที่ Drupal จะบู๊ตได้อย่างเต็มที่ในขณะที่ให้ความยืดหยุ่นแก่คุณว่าเป็นจุดใดในกระบวนการที่คุณต้องการดักจับ
หากคุณจำเป็นต้องตรวจสอบให้แน่ใจ Drupal ได้ booted drupal_bootstrap()จุดหนึ่งก่อนที่คุณจะดำเนินการต่อคุณสามารถโทรหา หากคุณคลิกผ่านไปยังเอกสารนั้นคุณสามารถดูระดับการบูตได้จากทุกอย่าง
และในที่สุดคุณสามารถดูรหัสเอกสารอย่างกว้างขวางบางอย่างสำหรับระบบย่อยใดก็ตามที่โครงการตัวอย่าง
hooks เป็นฟังก์ชั่น php ซึ่งเป็นพื้นฐานของการตั้งชื่อ "yourmodulename_hookname" ซึ่งมีวัตถุประสงค์เพื่อช่วยให้นักพัฒนาสามารถสร้างโมดูลได้ง่ายขึ้น
โมดูลเป็นเรื่องจริงเพราะมันเปิดใช้งาน CORE และฟังก์ชันที่กำหนดเองในระบบ Drupal ของคุณ ดังนั้นโมดูลที่ทำจากhooksและเมื่อโมดูลถูกเปิดใช้งานในการติดตั้ง Drupal ของคุณฟังก์ชั่น hooks สามารถเรียกได้จากโมดูลอื่น ๆ ขอบคุณฟังก์ชั่น module.inc module_invoke_all ($ hook)หรือ module_invoke
ดังนั้นเพื่อให้เข้าใจอย่างถูกต้องว่าตะขอคืออะไรคุณควรทำให้มือของคุณสกปรกและลองพัฒนาโมดูล เพื่อจุดประสงค์นี้เริ่มต้นด้วยการดาวน์โหลดและทดลองใช้ตัวอย่างบางส่วนสำหรับนักพัฒนาของDrupalคุณควรทำความคุ้นเคยกับการสร้างโมดูลเช่นกัน
นี่คือตัวอย่างของ Drupal ที่เป็นประโยชน์สำหรับนักพัฒนาที่กล่าวถึงข้างต้น:
hook_block_view ()ตัวอย่างการใช้งานในโมดูล block_example
/**
* @file examples/block_example/block_example.module line 127
*
* Implements hook_block_view().
*
* This hook generates the contents of the blocks themselves.
*/
function block_example_block_view($delta = '') {
//The $delta parameter tells us which block is being requested.
switch ($delta) {
case 'example_configurable_text':
// The subject is displayed at the top of the block. Note that it
// should be passed through t() for translation. The title configured
// for the block using Drupal UI supercedes this one.
$block['subject'] = t('Title of first block (example_configurable_text)');เบ็ดนี้ให้คุณเข้าถึงการสร้างบล็อกของ Drupal เพื่อแสดงบล็อกที่กำหนดเองบนเว็บไซต์ของคุณ เป็นไปได้เพราะ block.module มีฟังก์ชั่น _block_render_blockซึ่งเปิดใช้งานโมดูลทั้งหมดเพื่อกำหนดมุมมอง hook_block (สังเกตเห็นบรรทัดสุดท้ายของ module_invoke):
/**
* @file modules/block/block.module, line 838
*
* Render the content and subject for a set of blocks.
*
* @param $region_blocks
* An array of block objects such as returned for one region by _block_load_blocks().
*
* @return
* An array of visible blocks as expected by drupal_render().
*/
function _block_render_blocks($region_blocks) {
...
foreach ($region_blocks as $key => $block) {
...
$array = module_invoke($block->module, 'block_view', $block->delta);hook_menu ()ตัวอย่างการใช้งานในโมดูล render_example
/**
* @file examples/render_example/render_example.module line 22
*
* Implements hook_menu().
*/
function render_example_menu() {
...
$items['examples/render_example/arrays'] = array(
'title' => 'Render array examples',
'page callback' => 'render_example_arrays',
'access callback' => TRUE,
);เบ็ดนี้เชื่อมโยงกับระบบการจัดเส้นทาง url ของ Drupal และกำหนดรูปแบบ URL ด้วยการเรียกกลับที่เกี่ยวข้องที่ใช้โดยโมดูลของคุณ มันถูกเรียกจาก system.module
เกี่ยวกับ bootstrap โดยทั่วไปคุณเพียงแค่ต้องรู้ว่ามันถูกดำเนินการตามคำขอแต่ละหน้า ฉันแนะนำให้คุณอ่านคำตอบของ stackoverflow นี้มันอธิบายว่า bootstrap และ hooks สัมพันธ์กันอย่างไร แต่แยกกัน
เกี่ยวกับการแสดงผลของหน้าเว็บ, การแสดงผลเว็บไซต์ HTML ของ Drupal จะประสบความสำเร็จส่วนใหญ่กับการแสดงผลอาร์เรย์และชุดรูปแบบ
ทุกโมดูลจะเรียก module_implements () http://api.drupal.org/api/drupal/includes%21module.inc/function/module_implements/7 Drupal จะยิงฟังก์ชั่นที่มีชื่ออย่างถูกต้องตามลำดับที่ถูกต้องตามน้ำหนักของมัน สิ่งเหล่านี้เรียกว่าฟังก์ชั่น hook เพราะในเอกสารประกอบสำหรับโมดูลที่ใช้ module_implements คุณจะเห็นสิ่งต่าง ๆ เช่น hook_menu (สำหรับเมื่อเมนูเรียกฟังก์ชันทั้งหมดที่ออกแบบมาเพื่อส่งคืนรายการเมนู) คำว่า "hook" จะต้องถูกแทนที่ด้วยชื่อของโมดูลที่นำไปใช้งานและ Drupal จะดำเนินการส่วนที่เหลือ
นอกจากนี้ยังมีฟังก์ชั่น drupal_alter () ที่จะทำการยิงฟังก์ชั่นเปลี่ยนชื่ออย่างถูกต้องทั้งหมดด้วยความตั้งใจที่จะให้คุณแก้ไขสิ่งต่าง ๆ ที่ลงทะเบียนไว้ก่อนหน้านี้ด้วยตะขออื่น
โดยทั่วไปการเปลี่ยนแปลงจะผ่านการขัดแย้งโดยการอ้างอิงเพื่อให้คุณสามารถแก้ไขวัตถุโดยตรงในขณะที่ hooks "ปกติ" มักจะทำให้คุณได้รับสิ่งใหม่
แนวคิดก็คือโมดูลใด ๆ (รวมถึงของคุณเอง) สามารถขยายได้อย่างง่ายดายโดยขอให้ Drupal โทรหาฟังก์ชั่น hook ที่จำเป็นทั้งหมดและรับสิ่งที่พวกเขากลับมาเพื่อดำเนินการ โมดูลที่เรียกใช้ฟังก์ชั่น hook ไม่จำเป็นต้องรู้อะไรเกี่ยวกับโมดูลที่ติดตั้ง hooks และโมดูลที่ใช้ hook ไม่จำเป็นต้องรู้อะไรเกี่ยวกับโมดูลที่เรียกใช้ hook สิ่งเดียวที่ทั้งสองโมดูลจำเป็นต้องรู้คือโครงสร้างของข้อมูลที่ถูกส่งคืนหรือเปลี่ยนแปลง
ในทางปฏิบัติ hooks มักใช้เพื่อ:
คุณมีคำตอบมากมายข้างต้น แต่ฉันต้องการให้คำตอบในวิธีที่ง่ายกว่ามากในการทำความเข้าใจแนวคิดพื้นฐานที่อยู่เบื้องหลัง hooks Hooks ถูกสร้างขึ้นในฟังก์ชั่นใน drupal core เพื่อจัดการสิ่งต่าง ๆ และทำงานต่าง ๆ ในแกนคุณสามารถซิงโครไนซ์ฟังก์ชั่นของคุณเองกับฟังก์ชั่น drupal core ในตัวเพื่อเพิ่มฟังก์ชั่นของมันเอง
ฉันหวังว่าคุณจะได้รับคะแนน!
สำหรับฉันแล้วมันเกี่ยวกับฟังก์ชั่น module_implements เมื่อมันมาถึง hooks และ core (D7) สิ่งหนึ่งที่ฉันคิดว่าสำคัญอย่างยิ่งต่อการทำความเข้าใจคือการเขียนเบ็ดเพื่อแก้ไขบางสิ่งคุณไม่เคยพูดสิ่งสุดท้ายในสิ่งที่เกิดขึ้นกับโครงสร้างข้อมูลที่คุณกำลังเผชิญอยู่ เบ็ดของคุณจะอยู่ในแถว (คิว) ของฟังก์ชันที่ ALSO ทำหน้าที่ในโครงสร้างข้อมูลเดียวกันไม่ว่าจะเป็นเมนู, menu_links, บล็อก, โหนด, ผู้ใช้หรือเอนทิตี้หรือองค์ประกอบการแสดงผล
ดังนั้นการเห็นตะขอของคุณถูกนำมาใช้ในรูปแบบที่คาดหวังคุณจะต้องรู้หรือรู้ตัวว่าคุณอยู่ตรงไหน สิ่งนี้พิจารณาจากน้ำหนักของคุณ Drupal core เพียงเรียก hooks ที่มีชื่ออย่างถูกต้องในลำดับน้ำหนักขึ้นและสิ่งที่เกิดขึ้นกับข้อมูลที่เกิดขึ้น
ฉันเคยเขียน hooks มาก่อนแล้วว่าไม่มีผลใด ๆ เพียงแค่เรียนรู้หลังจากการใส่หูฟังหลายชั่วโมงว่าน้ำหนักของโมดูลของฉันเบาเกินไปและตะขอต่อเนื่องย่อย ๆ นั้นไม่ได้ทำสิ่งที่ฉันทำหรือไม่สนใจมันเลย
ตะขอที่เขียนอย่างดีจะไม่ "จัดการด้วยมือมนุษย์" หรือ "บังคับ" ตัวเองให้อยู่ได้ แต่จะ "ทำตัวดีกับคนอื่น" ด้วยการทำให้แน่ใจว่าพวกเขารักษาโครงสร้างข้อมูลตามที่คาดไว้โดยส่วนที่เหลือของ hooks ลงมา
และพูดถึง "The Line" ของ hooks ในช่วงหลายปีที่ผ่านมาฉันได้ลอง google เพื่อค้นหาสิ่งที่ Drupal ภาพนี้ดูเหมือนจะเป็นตัวแทนที่ดีของรายการก่อนหน้าและประมวลผลรายการของความเป็นไปได้
ในวิธีที่ง่ายกว่านี้ hooks ช่วยให้นักพัฒนาแก้ไขการทำงานที่มีอยู่ตามข้อกำหนดโดยไม่ต้องทำการเปลี่ยนแปลงรหัสที่มีอยู่ ฟังก์ชั่นอื่น ๆ ของ Abstract ใน php
ตัวอย่าง: คุณได้สร้างโมดูลสำหรับจองตั๋วรถโดยสาร ตามรหัสของคุณหากตั๋วถูกจองครั้งเดียวแล้วสถานที่รับไม่สามารถแก้ไขได้ซึ่งเป็นความต้องการของคุณสำหรับโครงการนั้นจัดหาให้เพื่อนของคุณต้องการโมดูลเดียวกันสำหรับความต้องการที่คล้ายกันยกเว้นผู้ใช้สามารถเปลี่ยนสถานที่รับ อย่างใดเขาต้องใช้โมดูลของคุณและคุณไม่ต้องการให้เขาทำการเปลี่ยนแปลงรหัสใด ๆ ดังนั้นคุณจึงจัดเตรียมอินเทอร์เฟซ (ขอใช้ในกรณีของเรา) ซึ่งเขาสามารถใช้การเปลี่ยนแปลงของเขาได้โดยไม่ต้องทำการเปลี่ยนแปลงในโมดูลของคุณ
ใน drupal จนถึง drupal-7 เรามี hooks สำหรับโมดูลรวมถึงธีม หากต้องการทราบว่าการตรวจสอบ hook ทำงานอย่างไร drupal.org hooksเพื่อสร้าง Hook แบบกำหนดเองตรวจสอบลิงค์นี้
ตะขอ อนุญาตให้โมดูลโต้ตอบกับแกน Drupal ระบบโมดูลของ Drupal ขึ้นอยู่กับแนวคิดของ "hooks" hook เป็นฟังก์ชัน PHP ที่ชื่อ foo_bar () โดยที่ "foo" เป็นชื่อของโมดูล (ซึ่งชื่อไฟล์นั้นเป็น foo.module) และ "bar" เป็นชื่อของ hook