8 คำตอบ
คุณสามารถใช้เทมเพลต Observer วิธีการใช้งานที่เรียบง่ายเพื่อให้บรรลุสิ่งนี้:
บทสรุป:
นี่คือแอปพลิเคชัน CRAZY ของฉัน 4 + 5 = 9 4 * 5 = 20
หมายเหตุ:
ในซอร์สโค้ดตัวอย่างนี้ คุณต้องประกาศปลั๊กอินทั้งหมดของคุณก่อนซอร์สโค้ดจริงที่คุณต้องการขยาย ฉันได้รวมตัวอย่างวิธีจัดการค่าตั้งแต่หนึ่งค่าขึ้นไปที่ส่งไปยังปลั๊กอิน ส่วนที่ยากที่สุดคือการเขียนเอกสารจริงที่แสดงรายการอาร์กิวเมนต์ที่ส่งผ่านไปยังแต่ละ hook
นี่เป็นเพียงวิธีหนึ่งในการสร้างระบบปลั๊กอินใน PHP มีทางเลือกอื่นที่ดีกว่า ฉันขอแนะนำให้คุณตรวจสอบเอกสาร WordPress เพื่อดูข้อมูลเพิ่มเติม
ขออภัย ดูเหมือนว่าขีดล่างจะถูกแทนที่ด้วยวัตถุ HTML Markdown ใช่ไหม ฉันอาจโพสต์โค้ดนี้อีกครั้งเมื่อข้อบกพร่องนี้ได้รับการแก้ไขแล้ว
แก้ไข: ไม่เป็นไร มันจะปรากฏเฉพาะเมื่อคุณกำลังแก้ไขเท่านั้น
สมมติว่าคุณไม่จำเป็นต้องมีรูปแบบ Observer เพราะว่ามันต้องการให้คุณเปลี่ยนวิธีการเรียนเพื่อจัดการกับงานการฟัง และคุณต้องการสิ่งที่เป็นแบบทั่วไป และสมมติว่าคุณไม่ต้องการใช้การขยายการสืบทอดเนื่องจากคุณอาจสืบทอดคลาสของคุณจากคลาสอื่นอยู่แล้ว จะดีกว่าไหมถ้ามีวิธีทั่วไปในการทำให้คลาสต่างๆ สามารถเสียบได้โดยไม่ต้องใช้ความพยายามมากนัก? มีวิธีดังนี้:
_Class = get_class(&$RefObject);
$this->_RefObject = $RefObject;
) ฟังก์ชั่นสาธารณะ __set($sProperty,$mixed) ( $sPlugin = $this->_Class . "_" . $sProperty . "_setEvent"; if (is_callable($sPlugin)) ( $mixed = call_user_func_array($sPlugin, $ ผสม); ) $this->_RefObject->$sProperty = $mixed; ) ฟังก์ชั่นสาธารณะ __get($sProperty) ( $asItems = (array) $this->_RefObject; $mixed = $asItems[$sProperty]; $sPlugin = $this->_Class . "_getEvent"; if (is_callable($sPlugin)) ( $mixed = call_user_func_array($sPlugin, $mixed); ) ส่งคืน $sMethod,$mixed) ( $sPlugin = $this->_Class . "_" . $sMethod . "_beforeEvent"; if (is_callable($sPlugin)) ( $mixed = call_user_func_array($sPlugin, $mixed); ) ถ้า ( $mixed != "BLOCK_EVENT") ( call_user_func_array(array(&$this->_RefObject, $sMethod), $sPlugin = $this->_Class . $sMethod . ถ้า ( is_callable($sPlugin)) ( call_user_func_array( $sPlugin, $mixed); ) ) ) //จบคลาส Plugin คลาส Pluggable ขยาย Plugin ( ) //จบคลาส Pluggable ////////////// ////// // PART 2 ///////////////////// คลาส Dog ( สาธารณะ $Name = "";
ฟังก์ชั่นสาธารณะ bark(&$sHow) ( echo "$sHow
\n"; ) ฟังก์ชั่นสาธารณะ sayName() ( echo "
\nชื่อของฉันคือ: " . $this->ชื่อ . "
ในส่วนที่ 3 เราจะเปลี่ยนคลาสของเราเป็น "ปลั๊กอิน" (เช่น ปลั๊กอินสนับสนุนที่ช่วยให้เราสามารถแทนที่วิธีการและคุณสมบัติของคลาสได้) ตัวอย่างเช่น หากคุณมีเว็บแอปพลิเคชัน คุณอาจมีการลงทะเบียนปลั๊กอิน และคุณสามารถเปิดใช้งานปลั๊กอินได้ที่นี่ โปรดสังเกตฟังก์ชัน Dog_bark_beforeEvent() ด้วย ถ้าฉันตั้งค่า $mixed = "BLOCK_EVENT" ก่อนคำสั่ง return มันจะบล็อกสุนัขไม่ให้เห่าและจะบล็อก Dog_bark_afterEvent ด้วยเพราะจะไม่มีเหตุการณ์เกิดขึ้น
ในส่วนที่ 4 นั่นเป็น opcode ปกติ แต่โปรดทราบว่าสิ่งที่คุณอาจคิดว่าไม่ได้ผลก็คือวิธีการทำงาน ตัวอย่างเช่น สุนัขไม่ได้ประกาศชื่อของเขาว่า "Fido" แต่เป็น "Coco" สุนัขไม่พูดว่า "เหมียว" แต่เป็น "โฮ่ง" และเมื่อคุณต้องการค้นหาชื่อสุนัขในภายหลัง คุณจะพบว่ามันเป็น "เบ็ดเตล็ด" ไม่ใช่ "Coco" การแทนที่ทั้งหมดนี้ถูกนำมาใช้ในส่วนที่ 3
แล้วมันทำงานยังไง? เอาล่ะ เรามาแยกแยะ eval() (ซึ่งใครๆ ก็บอกว่า "ชั่วร้าย") และแยกแยะว่านี่ไม่ใช่เทมเพลต Observer ดังนั้นวิธีการทำงานคือใช้คลาสว่างที่ซ่อนอยู่ซึ่งเรียกว่า Pluggable ซึ่งไม่มีวิธีการและคุณสมบัติที่ใช้โดยคลาส Dog ดังนั้น เมื่อสิ่งนี้เกิดขึ้น เราจะใช้วิธีเวทย์มนตร์เพื่อเรา นั่นเป็นสาเหตุที่ในส่วนที่ 3 และ 4 เราผูกกับอ็อบเจ็กต์ที่ได้มาจากคลาส Pluggable แทนที่จะเป็นคลาส Dog เอง แต่เราปล่อยให้คลาสปลั๊กอิน "สัมผัส" อ็อบเจ็กต์ Dog แทนเรา (หากนี่คือการออกแบบบางอย่างที่ฉันไม่รู้ - โปรดแจ้งให้เราทราบ)
วิธี hook และ Listener เป็นวิธีที่ใช้กันมากที่สุด แต่ก็มีอย่างอื่นที่คุณสามารถทำได้ ขึ้นอยู่กับขนาดของแอปพลิเคชันของคุณและใครที่ต้องการดูโค้ด (จะเป็นสคริปต์ FOSS หรือบางอย่างภายใน) จะมีอิทธิพลอย่างมากต่อวิธีที่คุณต้องการอนุญาตปลั๊กอิน
kdeloach มีตัวอย่างที่ดี แต่การนำไปปฏิบัติและฟังก์ชัน hook นั้นค่อนข้างไม่ปลอดภัย ฉันขอให้คุณให้ข้อมูลเพิ่มเติมเกี่ยวกับลักษณะของแอปพลิเคชัน php สำหรับจดหมายของคุณ และวิธีที่คุณเห็นปลั๊กอิน
1 ถึง kdeloach จากฉัน
นี่คือวิธีที่ฉันใช้ โดยพยายามคัดลอกจากกลไกสัญญาณ/สล็อตของ Qt ซึ่งเป็นรูปแบบของผู้สังเกตการณ์ วัตถุสามารถส่งสัญญาณได้ แต่ละสัญญาณมีตัวระบุในระบบ - ประกอบด้วย id + อ็อบเจ็กต์การส่ง แต่ละสัญญาณสามารถเชื่อมโยงกับตัวรับ ซึ่งก็คือ "ตัวเรียก" คุณใช้คลาสบัสเพื่อส่งสัญญาณไปยังใครก็ตามที่สนใจรับ เมื่อมีอะไรเกิดขึ้น คุณกำลังส่งสัญญาณ ด้านล่างนี้เป็นตัวอย่างและตัวอย่างการใช้งาน
เข้าสู่ระบบ (); -
ฉันเชื่อว่าวิธีที่ง่ายที่สุดคือทำตามคำแนะนำของ Jeff และดูโค้ดที่มีอยู่ ลองดูที่ Wordpress, Drupal, Joomla และ PHP CMS ที่มีชื่อเสียงอื่นๆ เพื่อดูว่า API ของพวกเขามีหน้าตาและความรู้สึกอย่างไร ด้วยวิธีนี้ คุณอาจได้รับแนวคิดที่คุณไม่เคยคิดมาก่อนเพื่อทำให้สิ่งต่างๆ หนาขึ้นอีกเล็กน้อย
คำตอบที่ตรงกว่าคือการเขียนไฟล์ทั่วไปที่จะรวมไว้ในไฟล์รวมเพื่อให้แน่ใจว่าใช้งานง่าย สิ่งนี้จะถูกจัดหมวดหมู่และไม่ได้ระบุไว้ในไฟล์ "hooks.php" ไฟล์ใหญ่เพียงไฟล์เดียว โปรดใช้ความระมัดระวัง เนื่องจากสิ่งที่เกิดขึ้นคือไฟล์ที่พวกเขารวมไว้นั้นมีการขึ้นต่อกันและฟังก์ชันการทำงานมากขึ้นเรื่อยๆ พยายามจำกัดการพึ่งพา API I.E มีไฟล์น้อยกว่าที่จะรวมไว้
มีโครงการเรียบร้อยที่เรียกว่า
cms mysql (4)
ฉันกำลังพยายามสร้างระบบปลั๊กอินพื้นฐานที่คล้ายกับที่คุณมักพบใน CMS เช่น WordPress คุณมีโฟลเดอร์ปลั๊กอินที่เชื่อมโยงกับการทำงานของระบบหลักโดยใช้การแจ้งเตือน เหตุการณ์ด้วยโดยใช้รูปแบบการออกแบบ ผู้สังเกตการณ์หรือ เหตุการณ์ .
ปัญหาคือระบบไม่สามารถรู้ได้ด้วย เหตุการณ์อะไรปลั๊กอินต้องการดำเนินการ - ดังนั้นระบบจะต้องโหลดปลั๊กอินแต่ละตัวสำหรับคำขอทุกหน้าเพื่อดูว่าปลั๊กอินนั้นจำเป็นจริงหรือไม่ในบางจุด ไม่จำเป็นต้องพูดว่า นั่นเป็นทรัพยากรที่สูญเปล่ามากมาย - ในกรณีของ WordPress ซึ่งเพิ่มหน่วยความจำเพิ่มเติมสองสาม MB สำหรับแต่ละคำขอ!
มีวิธีอื่นในการทำเช่นนี้หรือไม่?
ตัวอย่างเช่น มีวิธีโหลดทั้งหมดครั้งเดียวแล้วแคชผลลัพธ์เพื่อให้ระบบของคุณรู้วิธีโหลดปลั๊กอินแบบ Lazy Load หรือไม่ กล่าวอีกนัยหนึ่ง ระบบจะโหลดไฟล์การกำหนดค่าที่ระบุเหตุการณ์ทั้งหมดที่ปลั๊กอินต้องการเชื่อมโยง จากนั้นจัดเก็บไว้ใน APC หรือบางอย่างสำหรับคำขอในอนาคต
หากยังใช้งานไม่ได้ดี อาจมีโครงสร้างไฟล์พิเศษที่สามารถใช้เพื่อคาดเดาอย่างมีการศึกษาว่าเมื่อใดที่ไม่จำเป็นต้องใช้ปลั๊กอินบางตัวในการดำเนินการตามคำขอ
คำตอบ
ฉันมีเครื่องมือการจัดการปลั๊กอิน แต่ฉันใช้กับปลั๊กอินตามขั้นตอนเท่านั้น และเมื่อเปิดใช้งานทุกอย่าง โดยปกติแล้วจะโหลดพร้อมกัน แต่สำหรับ API แบบโหลดตามเหตุการณ์และแบบ Lazy Loading ฉันนึกภาพออกว่าใช้ Wrapper แบบตื้นเพื่อจัดการปลั๊กอินและใช้การโหลดอัตโนมัติสำหรับส่วนขยายจริง
php /** * api: อะไรก็ได้ * เวอร์ชัน: 0.1 * ชื่อ: ตัวอย่างปลั๊กอิน * คำอธิบาย: ... * config: * ขึ้นอยู่กับ: ปลั๊กอินอื่น ๆ */$plugins [ "title_event" ] = "TitleEventClass" ;$plugins [ "รอง" ] = array ( "Class2" , "callback" ); -
ในตัวอย่างนี้ ฉันถือว่า API ของปลั๊กอินเป็นรายการง่ายๆ สคริปต์ตัวอย่างนี้ features-plugin-123.php ไม่ได้ทำอะไรอื่นนอกจากเพิ่มลงในอาร์เรย์ขณะโหลด ดังนั้นแม้ว่าคุณจะมีปลั๊กอินฟีเจอร์หลายสิบปลั๊กอิน แต่จะส่งผลให้มีปลั๊กอินพิเศษเพิ่ม_หนึ่งครั้งต่อปลั๊กอินเท่านั้น
แต่แอปพลิเคชันหลัก / หรือ API ปลั๊กอินสามารถสร้างอินสแตนซ์คลาสดังกล่าวแทนได้ (ทั้ง $eventcb ใหม่; สำหรับ raw-call_user_func_array หรือ call_user_func_array สำหรับการโทรกลับ) ในทางกลับกัน จะทำให้งานจริงถูกดาวน์โหลดไปยังตัวโหลดอัตโนมัติ ดังนั้นคุณจึงมีระบบคู่ โดยที่ส่วนหนึ่งจัดการรายการ ส่วนอีกส่วนหนึ่งคือโค้ดจริง
php include_once ("user/feature-plugin-123.php" ); include_once ("user/otherplugin2.php" ); include_once (ฉันยังคงจินตนาการถึง config.php ง่ายๆ ที่แสดงรายการปลั๊กอินและการตั้งค่าดังนี้:"ผู้ใช้/wrapper-for-htmlpurifier.php"- $cfg [ "สวย" ] = 1 ;
โปรดคำนึงถึงอีกครั้งว่าสิ่งเหล่านี้เป็นเพียงตัวห่อข้อมูล/สคริปต์ พร้อมคำอธิบายปลั๊กอินสำหรับการจัดการ คุณยังสามารถใช้ register_even() API จริงและกำหนดฟังก์ชัน wrapper เพิ่มเติมในแต่ละฟังก์ชันได้ แต่รายชื่อเจ๋งๆ ดูเหมือนจะเป็นตัวเลือกที่ง่ายที่สุด
เครื่องมือการจัดการด้านบนดูเป็นสนิมและน่าเกลียด: http://milki.include-once.org/genericplugins/
แต่จะไม่ถูกใช้หากคุณต้องการเพียงรายการ (ตาราง sql) และการจัดการการตั้งค่า ค่าใช้จ่ายนี้มีไว้สำหรับการพิมพ์ข้อมูลเมตาของปลั๊กอินอย่างสวยงามและทำให้ config.php สามารถอ่านได้โดยมนุษย์
สรุปแล้ว:
ฉันจะเก็บชื่อคลาสปลั๊กอินพร้อมกับเหตุการณ์ที่เซ็นชื่อไว้ในไฟล์ปรับแต่ง จากนั้นเก็บไฟล์ปรับแต่งที่แยกวิเคราะห์ใน APC เป็นต้น จากนั้น เมื่อเหตุการณ์เกิดขึ้น ระบบสามารถโหลดคลาสปลั๊กอินที่เหมาะสมอย่างเกียจคร้านได้ตามต้องการ
Wordpress และระบบ CMS อื่นๆ เป็นตัวอย่างที่แย่มาก
เราต้องเข้าใจว่าโมดูลาร์มักจะหมายความว่ามันหนักกว่าเสมอ
รูปแบบที่ดีที่สุดที่ฉันเคยร่วมงานด้วยเพื่อแก้ไขสถานการณ์นี้คือปลั๊กอินตามคลาสซึ่งมีรูปแบบการตั้งชื่อที่เข้มงวด โดยใช้ตัวโหลดอัตโนมัติ
ดังนั้นก่อนที่จะใช้ปลั๊กอิน คุณต้องสร้างอินสแตนซ์หรือใช้ฟังก์ชันคงที่
คุณสามารถเรียกปลั๊กอินได้:
php $thePlugin :: method (); ?>ตัวอย่างเช่น:
php spl_autoload_register ("systemAutoload" ); function systemAutoload ($class ) { $parts = explode ("_" , $class ); switch ($parts [ 1 ]) { case "Plugin" : include ("/plugins/($parts)/($parts.php"- หยุดพัก ; -เกี่ยวกับเหตุการณ์:
คุณควรลงทะเบียนเหตุการณ์นี้แบบคงที่เพื่อหลีกเลี่ยงการแก้ไขแบบไดนามิก
ฐานข้อมูลจะเป็นสถานที่ที่เหมาะสมสำหรับสิ่งนี้ คุณสามารถมีตารางเหตุการณ์และวิธีการติดตั้ง() และถอนการติดตั้ง() ในคลาสปลั๊กอินของคุณเพื่อเพิ่มเหตุการณ์เฉพาะหรือวิธีผูกเข้ากับเหตุการณ์อื่น ๆ นี่เป็นแบบสอบถามฐานข้อมูลเดียว และหากคุณต้องการได้รับประโยชน์มากขึ้น ให้เพิ่มลงในไฟล์ memcached หรือไฟล์ ini แบบเรียบ
ทำงานได้ดีสำหรับฉัน ดังนั้นฉันจึงสามารถรับระบบขนาดใหญ่ที่ใช้ 8MB ต่อคำขอ ลดลงเหลือ 1MB เท่านั้น โดยมีรายการฟีเจอร์ที่เหมือนกันทุกประการโดยไม่ต้องแคชก่อน ตอนนี้เราสามารถเพิ่มคุณสมบัติเพิ่มเติมและทำให้ระบบ "สะอาด"
หวังว่านี่จะช่วยได้
วิธีที่ดีที่สุดคือเริ่มเขียนโค้ดกับพวกเขา รูปแบบการออกแบบเป็นแนวคิดที่ยอดเยี่ยมซึ่งเป็นเรื่องยากที่จะนำไปใช้โดยการอ่านเกี่ยวกับรูปแบบเหล่านั้น ยกตัวอย่างการใช้งานที่คุณพบทางออนไลน์และสร้างโดยคำนึงถึงสิ่งเหล่านั้น
ทรัพยากรที่ดีเยี่ยมคือหน้าข้อมูลและวัตถุ พวกเขาตรวจสอบรูปแบบและให้ตัวอย่างทั้งแนวคิดและในชีวิตจริงแก่คุณ เอกสารอ้างอิงของพวกเขาก็ยอดเยี่ยมเช่นกัน
ไฟล์ฟังก์ชั่นเป็นตัวช่วยที่ให้ความบันเทิงในการขยายฟังก์ชันการทำงานของเว็บไซต์! โดยเฉพาะอย่างยิ่งหากใช้เพื่อวัตถุประสงค์ที่ตั้งใจไว้ อย่างไรก็ตาม เจ้าของบล็อก/เว็บไซต์จำนวนมากได้เปลี่ยน Functions.php ให้กลายเป็นส่วนรวมอย่างน่าอัศจรรย์
ในธุรกิจใดๆ ก็ตาม มีเหตุผลและข้อจำกัดต่างๆ (ข้อจำกัด ซึ่งมักเป็นตรรกะ) ดังนั้นจึงเป็นการถูกต้องมากกว่าที่จะย้ายโค้ดปฏิบัติการบางส่วนที่ออกแบบมาเพื่อควบคุมพารามิเตอร์ของคอร์ WP (ไม่ใช่ธีม) ไปนอกเทมเพลต...
เมื่อพูดถึงการปรับปรุงฟังก์ชันการทำงานของเว็บไซต์ให้ทันสมัย ในบทความ "ไม่มีปลั๊กอิน..." พวกเขาแนะนำให้ใส่บล็อกโค้ดทั้งหมดลงใน Functions.php ที่เป็นตำนานอย่างแน่นอน นี่ผิด!
มีเหตุผลมากกว่าที่จะถ่ายโอนส่วนขยายทางเทคนิคทั้งหมด (ไม่เกี่ยวข้องโดยตรงกับสไตล์เทมเพลต) ไปยังปลั๊กอินที่จัดระเบียบสำหรับการลงทะเบียน
มาสร้างมันกันเถอะ! และเราจะพูดถึงข้อดีข้อเสีย (ซึ่งมีน้อยกว่ามาก)...
ส่วนของบทความ:
วิธีสร้างปลั๊กอินของคุณเอง
ในข้อความด้านล่างเราจะได้เรียนรู้วิธีสร้างปลั๊กอินของคุณเองด้วยมือของคุณเอง: เราจะเข้าใจรายละเอียดและความแตกต่างทั้งหมด มาดูกันว่าข้อดีข้อเสียคืออะไร (มีข้อเสียน้อยกว่า!! และสิ่งเหล่านี้ไม่ใช่ข้อเสียเลย แต่เป็นข้อดีอย่างใดอย่างหนึ่งสำหรับผู้ดูแลระบบแต่ละคน)
ความแตกต่างระหว่างไฟล์ function.php และปลั๊กอินคืออะไร
เหตุใดโค้ดบางส่วนจึงควรย้ายโดยตรงไปยังฟังก์ชันการทำงานของไซต์ไปยังปลั๊กอินแยกต่างหาก
ไฟล์ฟังก์ชั่นนั้นเอง วัตถุประสงค์ และความสอดคล้องของมันไม่แตกต่างจากปลั๊กอิน (เพียงแค่ปลั๊กอินในธีม))! — หน้าที่หลักคือการตกแต่งเทมเพลตเฉพาะ (ที่ใช้งานอยู่) ด้วยฟังก์ชันที่มีประโยชน์
ตัวอย่างเช่น "การนำทาง" โดยที่เมนูของปุ่มได้รับการตกแต่งอย่างมีเหตุผลด้วย CSS ตามสไตล์ของธีมที่ใช้งานอยู่ - บางทีมันอาจจะถูกต้องกว่าถ้าปล่อยไว้ในรูทของเทมเพลต
ประโยชน์ของการแยกไฟล์ฟังก์ชั่นออกเป็นไฟล์แยกกันหรือปลั๊กอินแยกคืออะไร?
ตัวอย่างเช่นสิ่งที่ซ้ำซากที่สุด - คุณตัดสินใจเปลี่ยนเทมเพลต!? ...ผลก็คือ การพัฒนาฟังก์ชันทั้งหมดจะหายไป เนื่องจากโค้ดที่มีประโยชน์ทั้งหมดอยู่ในไฟล์ฟังก์ชัน (ฉันเคยเห็นไฟล์ขนาด 750kILO เช่นนี้)
แน่นอนคุณสามารถย้ายเอกสารประกอบของฟังก์ชั่นไปยังหัวข้อใหม่ได้ แต่บ่อยครั้งที่คุณไม่สามารถทำได้หากไม่มีการแก้ไขซึ่งใช้เวลานานมาก: ลิงและแรงงาน)
และนอกจากนั้น:
ลำดับการดาวน์โหลดไฟล์เว็บไซต์
โดยสังเขป: ลำดับการโหลดไฟล์ไซต์หลักในตัวอย่างของเรามีดังนี้ - ปลั๊กอินของไซต์ที่ใช้งานอยู่ (จากโฟลเดอร์ปลั๊กอิน) และเนื้อหาจะถูกโหลดเร็วขึ้นเล็กน้อย จากนั้นจึงประมวลผลไฟล์ function.php ที่มีเนื้อหาเท่านั้น ทั้งหมดนี้เป็นมิลลิวินาทีและแทบจะไม่คุ้มค่าที่จะพูดถึงการเพิ่มความเร็วเพจอย่างจริงจัง
แม้ว่าดูเหมือนว่าเหตุผลประการหนึ่งสำหรับลำดับการโหลดนี้กำหนดโดยนักพัฒนาโดยที่ไฟล์ฟังก์ชันได้รับตำแหน่งที่สอง (เช่น คงจะองค์ประกอบที่เบากว่า) ซึ่งเป็นเพียงข้อเท็จจริงของการใช้ปลั๊กอินอย่างแพร่หลาย มักจะมีเนื้อหาจำนวนมาก...
บางคนจะอุทาน: ปลั๊กอินอื่น...? มันยาก!
และฉันบอกว่าสิ่งนี้จะไม่ส่งผลกระทบต่อความเร็วใดๆ... แต่ในทางกลับกัน หากคุณเข้าใกล้การสร้างเว็บไซต์อย่างรอบคอบ
นอกจากนี้ประโยชน์ของการโอนโค้ดบางส่วนยังเห็นได้ชัดในอีกทางหนึ่ง กล่าวคือ ความเร็วในการโหลดไซต์ไม่ได้ขึ้นอยู่กับจำนวนปลั๊กอินที่ใช้งานอยู่ แต่ขึ้นอยู่กับเนื้อหาด้วย! แล้วทำไมไม่ลดไฟล์ฟังก์ชั่นที่อย่างที่บอกไปโหลดทีหลังหน่อยล่ะ..? และยิ่งไปกว่านั้น มันเป็นปลั๊กอินระดับเทมเพลตขนาดใหญ่ที่เต็มเปี่ยม! แล้วโค้ดส่วนใหญ่ของเขาไปอยู่ที่ไหน?
ในความคิดของฉัน เทมเพลต (ใช้งานอยู่และใช้งานได้) ควรมีเฉพาะพารามิเตอร์ที่เกี่ยวข้องโดยเฉพาะเท่านั้น
เที่ยวคณิตศาสตร์...
- ถูกโหลดในภายหลัง คำถามคือ ทำไมไม่ย้ายไปยังสถานที่ที่ประมวลผลโค้ดเป็นหลัก และด้วยเหตุนี้ การแก้ไขพารามิเตอร์หลัก WP ที่ระบุโดยผู้ดูแลระบบจะถูกอ่านเร็วขึ้นและประมวลผลในขั้นตอนที่เหมาะสมของไซต์ ปล่อย?
- ความได้เปรียบอันฉาวโฉ่และการจัดระเบียบเชิงตรรกะของฟังก์ชันการทำงานของไซต์
- ความสะดวกสบายซึ่งไม่สำคัญ!
นอกจากนี้ ตามที่กล่าวไว้ ไฟล์ฟังก์ชันเป็นปลั๊กอินเดียวกัน - ฉันจะถามอีกครั้งว่าทำไมต้องยัดทุกอย่างลงไป? และในขณะที่ทำงานกับไซต์ คุณจะสับสนกับเอกสารโค้ดขนาดใหญ่ที่อ่านยาก ซึ่งในทางกลับกัน เนื้อหาในนั้นเต็มไปด้วยความเหลือเชื่อและไม่มีเหตุผล
การสร้างปลั๊กอินน้ำหนักเบานั้นง่ายและสมเหตุสมผลมากกว่า ตั้งค่าและลืมมันไปได้เลย...
ทุกคนตัดสินใจด้วยตัวเองว่าจะฟังประสบการณ์ของตนเองหรือความคิดเห็นของผู้เขียนบทความทางการศึกษาบางเรื่อง
ในขณะที่เราควรศึกษา WordPress ในห้องสมุด แต่ไม่ใช่จากบทความ... คุณสามารถรวบรวมเฉพาะแนวคิดนี้หรือแนวคิดนั้นจากบทความ...
อะไรประมาณนี้)
...สำหรับผู้ที่สนใจ:
คุณสามารถศึกษากฎทั้งหมดของเคอร์เนล (และลำดับของการโหลดไดเร็กทอรีเคอร์เนล)) ได้อย่างยอดเยี่ยมในโค้ด WordPress
...หนึ่งในบทความต่อไปนี้จะมีหัวข้อ Baedeker เช่นนี้! ...และลิงค์ไปยังหน้าเพจที่เป็นประโยชน์
!..โดยสมัครรับข้อมูลอัพเดตเว็บไซต์ -
...ขอเป็นส่วนหนึ่งกับความไม่รู้..!
วิธีสร้างไฟล์เสริมปลั๊กอิน function.php
แน่นอนว่าปลั๊กอินที่เป็นปัญหานั้นเป็นวิธีแก้ปัญหาง่ายๆ แต่การเรียนรู้ควรเริ่มต้นจากพื้นฐาน!
ยิ่งไปกว่านั้น เพื่อให้บรรลุเป้าหมายในบทความ ไม่จำเป็นต้องใช้ปลั๊กอินที่ทรงพลัง!
ไปที่แผงควบคุมการโฮสต์ (หรือใช้ FTP) แล้วเปิดตัวจัดการไฟล์
เปิดโฟลเดอร์ปลั๊กอินและสร้างไดเร็กทอรีอื่นในนั้น (โฟลเดอร์สำหรับไฟล์ปลั๊กอินของเรา) ชื่อใด ๆ ในภาษาละติน ฉันมีชื่อ "ทดสอบ" เป็นตัวอย่าง
โปรดทราบว่าชื่อของปลั๊กอินในแผงผู้ดูแลระบบจะเหมือนกับชื่อที่ระบุไว้ในส่วนหัวข้อมูล ชื่อปลั๊กอิน: ทดสอบ (ดูความคิดเห็น)
เปิดโฟลเดอร์ที่สร้างขึ้นและสร้างไฟล์ปลั๊กอินหลักในนั้น:
...ระบุชื่อ พูด my-functions.php และเพิ่มบรรทัดต่อไปนี้ในส่วนเนื้อหา (และชื่อไฟล์สามารถเป็นอะไรก็ได้)
บรรทัดในความคิดเห็นเป็นข้อมูลเกี่ยวกับปลั๊กอินที่จะปรากฏในแผงผู้ดูแลระบบ (เมนูปลั๊กอิน)
ทันทีหลังจากที่คุณสร้างโฟลเดอร์และไฟล์ ปลั๊กอินของคุณจะปรากฏในแผงผู้ดูแลระบบ ดู.
ในฐานะอดีต คุณสามารถเปิดใช้งานได้สักพัก - แต่จะไม่มีอะไรเกิดขึ้น ปลั๊กอินยังคงไม่ได้ใช้งาน
แค่นั้นแหละ!! มีการสร้างปลั๊กอินง่ายๆ และด้วยมือของคุณเองและเพื่อผลประโยชน์ของคุณเองอย่างน่าทึ่ง (อย่างที่แมว Matroskin เคยพูด)
เมื่อถึงจุดนี้ม่านการแสดงก็ปิดลง...
...ฝุ่นเศร้าตกตามทางลาด...
นี่เป็นภาพยนตร์ที่มีประโยชน์จากซีรีส์ "ไม่มีปลั๊กอิน" - ลองดูสิ ลองคิดดูว่าโค้ดที่เสนอในวิดีโอควรเหลืออยู่ในไฟล์ฟังก์ชันหรือไม่
เมื่อท่องอินเทอร์เน็ต ทุกคนต้องการให้หน้าเว็บไซต์โหลดเร็วที่สุดเท่าที่จะเป็นไปได้ ไม่มีใครชอบที่จะรอเป็นเวลานานกว่าหน้าใดหน้าหนึ่งจะโหลด นอกจากนี้ การรอนี้อาจล่าช้าออกไปได้ค่อนข้างมากในกรณีที่หน้าเว็บมีรูปภาพจำนวนมาก การแสดงรูปภาพบนเพจทำให้เพจน่าสนใจยิ่งขึ้นสำหรับผู้เยี่ยมชม เพิ่มการมองเห็น และช่วยเพิ่มการเข้าชมไซต์ของคุณในที่สุด อย่างไรก็ตาม เราต้องคำนึงถึงความจริงที่ว่าการมีรูปภาพทำให้หน้าเว็บมีน้ำหนักมากขึ้น ทำให้เวลาในการโหลดเพิ่มขึ้น
การโหลดหน้าเว็บช้าส่งผลเสียต่อการเพิ่มประสิทธิภาพ SEO ของเว็บไซต์ของคุณ ในปัจจุบัน เว็บไซต์จำนวนมากใช้รูปภาพ GIF หรือ PNG ในโพสต์ของตน รูปภาพเหล่านี้มีขนาดใหญ่กว่ารูปภาพ JPEG และด้วยเหตุนี้ หน้าเว็บจึงอาจใช้เวลาโหลดนานขึ้นอีก หากต้องการดาวน์โหลดแต่ละภาพดังกล่าว จำเป็นต้องมีคำขอ HTTP แยกต่างหาก ซึ่งไม่ได้ทำให้การดาวน์โหลดเร็วขึ้นเช่นกัน
เพื่อแก้ไขปัญหานี้ มีการใช้สิ่งที่เรียกว่า "ขี้เกียจ" หรือการโหลดแบบเลื่อนออกไป ซึ่งจะโหลดเฉพาะภาพที่ผู้ใช้ต้องการเท่านั้น บทความนี้จะอธิบายหกปลั๊กอินโหลดขี้เกียจ WordPress ที่ดีที่สุดฟรีซึ่งสามารถปรับปรุงความเร็วในการโหลดหน้าเว็บได้อย่างมาก
1. a3 Lazy Load - ปลั๊กอินโหลดขี้เกียจที่ดีที่สุด
ปลั๊กอินช่วยเพิ่มความเร็วให้กับบล็อกของคุณและปรับปรุงการตอบสนองภาพของเพจบนพีซี แท็บเล็ต และโทรศัพท์มือถือ
a3 Lazy Load ไม่ได้สร้างภาระบนเว็บไซต์และเหมาะกับมือถือ ปลั๊กอินที่ใช้งานง่ายที่จะเพิ่มความเร็วเว็บไซต์ของคุณ ยิ่งไซต์ของคุณมีองค์ประกอบหนักมากเท่าใด ปลั๊กอินก็จะทำงานได้ดีขึ้นเท่านั้น และคุณจะเห็นการปรับปรุงประสิทธิภาพมากขึ้นด้วย
- การโหลดแบบ Lazy Loading สำหรับรูปภาพ กราวาตาร์ วิดีโอ และเฟรมทั้งหมด
- การเลือกเอฟเฟกต์การโหลด
- การสนับสนุน WooCommerce
- ประสิทธิภาพสูงและโหลดต่ำ
- คุณสามารถยกเว้นรูปภาพและวิดีโอได้
- การเชื่อมต่อ JavaScript สำรอง
- รองรับเบราว์เซอร์ทั้งหมด
2.ขี้เกียจโหลด
นี่เป็นปลั๊กอินรูปภาพโหลดแบบขี้เกียจที่พัฒนาโดย WordPress.com ทีม TechCrunch และ Jack Goldman มีโค้ดง่ายๆ จึงไม่ทำให้ทรัพยากรเซิร์ฟเวอร์มากเกินไป
Lazy เป็นปลั๊กอินที่ติดตั้งและกำหนดค่าได้ง่าย แทบไม่ต้องตั้งค่าใดๆ เริ่มทำงานทันทีหลังการติดตั้ง
ลักษณะสำคัญของปลั๊กอิน:
- รหัสง่ายๆ
- ขับเคลื่อนโดยเวิร์ดเพรส
- ใช้งานง่าย.
- ใช้ jQuery.sonar
3. บีเจ ขี้เกียจ โหลด
BJ เป็นอีกหนึ่งปลั๊กอิน WordPress ที่โหลดแบบ Lazy Loading ฟรี ซึ่งจะแทนที่รูปภาพ รูปภาพขนาดย่อ Gravatar และเนื้อหาองค์ประกอบ iframe ทั้งหมดของคุณในพื้นที่ที่ถูกติดตามด้วย “stub” รูปภาพจะถูกโหลดหลังจากที่ปรากฏในหน้าต่างเบราว์เซอร์ วิธีนี้ช่วยให้คุณเพิ่มความเร็วในการโหลดหน้าเว็บและประหยัดปริมาณการเข้าชมของผู้ใช้
ปลั๊กอินมีการออกแบบที่ตอบสนองซึ่งช่วยให้สามารถทำงานกับอุปกรณ์มือถือได้ บนอุปกรณ์เคลื่อนที่ รูปภาพจะถูกปรับขนาดให้พอดีกับขนาดหน้าจอโดยอัตโนมัติ ปลั๊กอินนี้พร้อมสำหรับ Retina แล้ว ซึ่งหมายความว่าสามารถทำงานบนอุปกรณ์ Apple ได้
ลักษณะสำคัญของปลั๊กอิน:
- การแทนที่รูปภาพด้วย "ต้นขั้ว"
- การปรับขนาดรูปภาพอัตโนมัติ
- รองรับจอประสาทตา
- ประหยัดการรับส่งข้อมูลของผู้ใช้
4. jQuery ขี้เกียจโหลด
jQuery เป็นปลั๊กอินโหลดแบบ Lazy Loading ฟรีที่ใช้สคริปต์ Java สคริปต์ Java จะโหลดรูปภาพเมื่ออยู่ในพื้นที่ที่มองเห็นได้ของหน้าต่างเบราว์เซอร์เท่านั้น
jQuery เป็นปลั๊กอินยอดนิยมจากแหล่งเก็บข้อมูล WordPress
ลักษณะสำคัญของปลั๊กอิน:
- ความนิยม.
- การใช้สคริปต์จาวา
- ปริมาณขนาดเล็ก
- แทบไม่จำเป็นต้องมีการตั้งค่าใดๆ
5. โหลด Lazy ขั้นสูง
นี่เป็นปลั๊กอิน WordPress สำหรับการโหลดแบบขี้เกียจที่ดีมากซึ่งจะโหลดรูปภาพเมื่อผู้ใช้เลื่อนหน้าลงและไปถึงบริเวณรูปภาพ ปลั๊กอินนี้ยังใช้สคริปต์ jQuery ช่วยให้คุณลดเวลาในการโหลดได้ เนื่องจากข้อความจะถูกโหลดก่อน และสร้างการเชื่อมต่อ HTTP ใหม่สำหรับรูปภาพ
ความจริงที่ว่าเพจไม่ได้โหลดพร้อมกันทำให้คุณสามารถลดจำนวนการเชื่อมต่อ HTTP และลดภาระบนเซิร์ฟเวอร์ได้อย่างมาก
ลักษณะสำคัญของปลั๊กอิน:
- ใช้สคริปต์ jQuery
- ช่วยให้คุณลดจำนวนการเชื่อมต่อ HTTP
- ช่วยให้คุณเพิ่มความเร็วในการโหลดหน้าเว็บ
- มีการตั้งค่าสองประเภท
6. เปิดตัว Lazy Load
นี่เป็นปลั๊กอินขนาดเล็กมากที่ใช้สคริปต์ jQuery โหลดรูปภาพโดยใช้สคริปต์ที่มีขนาดเพียง 0.6 KB ปลั๊กอินช่วยให้คุณลดภาระบนเซิร์ฟเวอร์โดยลดจำนวนการเชื่อมต่อ
รูปภาพถูกโหลดลงในโค้ด HTML ของเพจโดยใช้ข้อมูล: รูปแบบ URL ซึ่งช่วยลดความจำเป็นในการทำซ้ำรูปภาพซึ่งจำเป็นสำหรับการโหลดแบบ Lazy Loading
ลักษณะสำคัญของปลั๊กอิน:
- ใช้สคริปต์ jQuery
- ใช้สคริปต์ที่มีน้ำหนักเบา
- ใช้รูปแบบที่มีข้อมูล: URL
- ช่วยให้คุณลดจำนวนการเชื่อมต่อ
บทสรุป
บทความนี้จะอธิบายปลั๊กอินรูปภาพโหลดขี้เกียจของ WordPress ฟรีที่จะช่วยให้หน้าไซต์ WordPress ของคุณโหลดเร็วขึ้น ด้วยความช่วยเหลือของปลั๊กอินเหล่านี้คุณสามารถสร้างปาฏิหาริย์ได้ เขียนความคิดเห็นว่าคุณใช้ปลั๊กอินรูปภาพโหลดขี้เกียจอะไร
ปลั๊กอินเป็นวิธีหนึ่งในการขยายฟังก์ชันการทำงานของแอปพลิเคชันโดยไม่ต้องเปลี่ยนซอร์สโค้ด
ฟังก์ชั่นที่ใช้งานโดยปลั๊กอินยังคงทำงานต่อไปหลังจากติดตั้งการอัปเดตแอปพลิเคชัน เมื่อมีการเขียนทับไฟล์ ซอร์สโค้ดของปลั๊กอินถูกคอมไพล์เป็นไฟล์อิสระที่เชื่อมต่อกับแอปพลิเคชันเท่านั้น
รองรับหลายภาษา
- การแปลปลั๊กอินจะดำเนินการในลักษณะที่คล้ายกันอย่างสิ้นเชิงกับการแปลแอปพลิเคชัน (เอกสารประกอบ) ในโฟลเดอร์ locale คุณควรวางไฟล์การแปล *.po และ *.mo และรวมคีย์ต่างๆ ไว้ในโค้ดดังนี้: _wp("สตริง")
- ใน PHP (แทนที่จะเป็นเมธอด _w() ซึ่งใช้ได้กับการแปลแอปพลิเคชันเท่านั้น คุณควรใช้เมธอด _wp() ซึ่งจะโหลดการแปลปลั๊กอิน)[`สตริง`]
ในเทมเพลต Smarty (ไม่มีความแตกต่างจากการแปลแอปพลิเคชันที่นี่)
ชื่อและคำอธิบายของปลั๊กอิน (ชื่อและคำอธิบายในไฟล์กำหนดค่า) ได้รับการแปลโดยใช้การแปลปลั๊กอินเริ่มต้น ดังนั้นจึงไม่จำเป็นต้องระบุ "name" => _wp("PLUGIN NAME") - เพียงระบุ "name" = > "ชื่อปลั๊กอิน" .
ในกรณีของการเรียกเมธอดสาธารณะของคลาสปลั๊กอินในสภาพแวดล้อมภายนอก ตัวอย่างเช่น ในโค้ดธีม การแปลปลั๊กอินจะไม่เชื่อมต่อโดยอัตโนมัติ และฟังก์ชัน _wp() จะไม่ส่งคืนบรรทัดใหม่ตามที่คาดไว้ หากต้องการใช้การแปลปลั๊กอินในวิธีการดังกล่าว คุณต้องวางการเรียกฟังก์ชัน _wp() ทั้งหมดภายในโครงสร้างพิเศษ ซึ่งแสดงเป็นตัวหนาในตัวอย่างด้านล่าง:
Class appMyPlugin ขยาย waPlugin ( public static function displayData() ( //ในทั้งสองบรรทัดระบุ ID ของแอปพลิเคชันและปลั๊กอินของคุณ waLocale::loadByDomain(array("app_id", "plugin_id")); waSystem::pushActivePlugin("plugin_id "," app_id"); $result = _wp("..."); waSystem::popActivePlugin();ส่งกลับผลลัพธ์ $;
-
ฐานข้อมูล หากปลั๊กอินใช้ตารางของตัวเองในฐานข้อมูล ชื่อตารางควรเริ่มต้นด้วยส่วนย่อยเช่น __ ตัวอย่างเช่น:ร้านค้า_ebay_
ชื่อตาราง
กำลังเชื่อมต่อปลั๊กอิน เพื่อให้ปลั๊กอินที่เขียนทำงานได้ คุณต้องเปิดใช้งานในไฟล์การกำหนดค่าระบบแอปพลิเคชัน wa-config/แอพ/
APP_ID/plugins.php โดยเพิ่มบรรทัดเข้าไป:
"plugin_id" => จริง
ตัวอย่างของไฟล์นี้สำหรับแอปพลิเคชัน Blog (wa-config/apps/blog/plugins.php):
จริง, "tag" => จริง, "หมวดหมู่" => จริง, "gravatar" => จริง, "รายการโปรด" => จริง, "หมุนรอบ" => จริง,);
ในไฟล์เดียวกันคุณสามารถปิดการใช้งานปลั๊กอินที่ไม่จำเป็นได้
install.php และถอนการติดตั้ง.php เมื่อติดตั้งปลั๊กอิน หากคุณจำเป็นต้องดำเนินการบางอย่างที่ไม่เป็นไปตามมาตรฐาน (เช่น การเพิ่มฟิลด์ใหม่ลงในตารางแอปพลิเคชันที่มีอยู่) จะต้องอธิบายตรรกะของการดำเนินการดังกล่าวในไฟล์การกำหนดค่า lib/config/ติดตั้ง.php
- ตัวอย่างการเพิ่มฟิลด์เพิ่มเติมลงในตารางเมื่อติดตั้งปลั๊กอิน:
$model = waModel ใหม่(); ลอง ( $model->query("SELECT `custom_field` FROM `shop_product` WHERE 0"); ) catch (waDbException $e) ( $model->exec("ALTER TABLE `shop_product` ADD `custom_field` INT(11) ไม่ได้ลงนาม NULL ค่าเริ่มต้น NULL"); ) การดำเนินการที่ต้องดำเนินการเมื่อลบปลั๊กอินมีการอธิบายในลักษณะเดียวกันในไฟล์ lib/config/ .
ถอนการติดตั้ง.php การสร้างและการลบเป็นเจ้าของ
ไม่จำเป็นต้องอธิบายตารางปลั๊กอินในไฟล์ install.php และ Uninstall.php ตารางจะถูกสร้างขึ้นและลบโดยอัตโนมัติตามเนื้อหาของไฟล์คอนฟิกูเรชันอื่น: db.php ซม. " "
แพลตฟอร์มปลั๊กอินถูกนำมาใช้ในกรอบงานพร้อมกับแอปพลิเคชัน "บล็อก" ดังนั้นสำหรับการศึกษาเพิ่มเติม เราแนะนำให้ติดตั้งแอปพลิเคชันนี้และตรวจสอบปลั๊กอินที่เขียนขึ้นสำหรับมัน (ปลั๊กอินได้รับการติดตั้งผ่าน "ตัวติดตั้ง") บล็อกมีการเขียนปลั๊กอินประเภทต่างๆ และแอปพลิเคชันที่ใช้งานได้จริง: สำหรับส่วนหน้า ส่วนหลัง การขยายความสามารถของอินเทอร์เฟซผู้ใช้ การอัปโหลดข้อมูล ฯลฯ