ปลั๊กอิน php ที่ถูกต้อง Php on: คุณจะสร้างระบบปลั๊กอินได้อย่างไรเพื่อไม่ให้เปลืองทรัพยากรมากนัก? จะเป็นเช่นไร

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 แบบตื้นเพื่อจัดการปลั๊กอินและใช้การโหลดอัตโนมัติสำหรับส่วนขยายจริง

/** * 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 สำหรับการโทรกลับ) ในทางกลับกัน จะทำให้งานจริงถูกดาวน์โหลดไปยังตัวโหลดอัตโนมัติ ดังนั้นคุณจึงมีระบบคู่ โดยที่ส่วนหนึ่งจัดการรายการ ส่วนอีกส่วนหนึ่งคือโค้ดจริง

ฉันยังคงจินตนาการถึง config.php ง่ายๆ ที่แสดงรายการปลั๊กอินและการตั้งค่าดังนี้:"ผู้ใช้/wrapper-for-htmlpurifier.php"

- $cfg [ "สวย" ] = 1 ;

โปรดคำนึงถึงอีกครั้งว่าสิ่งเหล่านี้เป็นเพียงตัวห่อข้อมูล/สคริปต์ พร้อมคำอธิบายปลั๊กอินสำหรับการจัดการ คุณยังสามารถใช้ register_even() API จริงและกำหนดฟังก์ชัน wrapper เพิ่มเติมในแต่ละฟังก์ชันได้ แต่รายชื่อเจ๋งๆ ดูเหมือนจะเป็นตัวเลือกที่ง่ายที่สุด
เครื่องมือการจัดการด้านบนดูเป็นสนิมและน่าเกลียด: http://milki.include-once.org/genericplugins/

แต่จะไม่ถูกใช้หากคุณต้องการเพียงรายการ (ตาราง sql) และการจัดการการตั้งค่า ค่าใช้จ่ายนี้มีไว้สำหรับการพิมพ์ข้อมูลเมตาของปลั๊กอินอย่างสวยงามและทำให้ config.php สามารถอ่านได้โดยมนุษย์

สรุปแล้ว:

ฉันจะเก็บชื่อคลาสปลั๊กอินพร้อมกับเหตุการณ์ที่เซ็นชื่อไว้ในไฟล์ปรับแต่ง จากนั้นเก็บไฟล์ปรับแต่งที่แยกวิเคราะห์ใน APC เป็นต้น จากนั้น เมื่อเหตุการณ์เกิดขึ้น ระบบสามารถโหลดคลาสปลั๊กอินที่เหมาะสมอย่างเกียจคร้านได้ตามต้องการ

Wordpress และระบบ CMS อื่นๆ เป็นตัวอย่างที่แย่มาก

เราต้องเข้าใจว่าโมดูลาร์มักจะหมายความว่ามันหนักกว่าเสมอ

รูปแบบที่ดีที่สุดที่ฉันเคยร่วมงานด้วยเพื่อแก้ไขสถานการณ์นี้คือปลั๊กอินตามคลาสซึ่งมีรูปแบบการตั้งชื่อที่เข้มงวด โดยใช้ตัวโหลดอัตโนมัติ

ดังนั้นก่อนที่จะใช้ปลั๊กอิน คุณต้องสร้างอินสแตนซ์หรือใช้ฟังก์ชันคงที่

คุณสามารถเรียกปลั๊กอินได้:

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

"/plugins/($parts)/($parts.php"- หยุดพัก ; -

เกี่ยวกับเหตุการณ์:

คุณควรลงทะเบียนเหตุการณ์นี้แบบคงที่เพื่อหลีกเลี่ยงการแก้ไขแบบไดนามิก

ฐานข้อมูลจะเป็นสถานที่ที่เหมาะสมสำหรับสิ่งนี้ คุณสามารถมีตารางเหตุการณ์และวิธีการติดตั้ง() และถอนการติดตั้ง() ในคลาสปลั๊กอินของคุณเพื่อเพิ่มเหตุการณ์เฉพาะหรือวิธีผูกเข้ากับเหตุการณ์อื่น ๆ นี่เป็นแบบสอบถามฐานข้อมูลเดียว และหากคุณต้องการได้รับประโยชน์มากขึ้น ให้เพิ่มลงในไฟล์ memcached หรือไฟล์ ini แบบเรียบ

ทำงานได้ดีสำหรับฉัน ดังนั้นฉันจึงสามารถรับระบบขนาดใหญ่ที่ใช้ 8MB ต่อคำขอ ลดลงเหลือ 1MB เท่านั้น โดยมีรายการฟีเจอร์ที่เหมือนกันทุกประการโดยไม่ต้องแคชก่อน ตอนนี้เราสามารถเพิ่มคุณสมบัติเพิ่มเติมและทำให้ระบบ "สะอาด"

หวังว่านี่จะช่วยได้

วิธีที่ดีที่สุดคือเริ่มเขียนโค้ดกับพวกเขา รูปแบบการออกแบบเป็นแนวคิดที่ยอดเยี่ยมซึ่งเป็นเรื่องยากที่จะนำไปใช้โดยการอ่านเกี่ยวกับรูปแบบเหล่านั้น ยกตัวอย่างการใช้งานที่คุณพบทางออนไลน์และสร้างโดยคำนึงถึงสิ่งเหล่านั้น

ทรัพยากรที่ดีเยี่ยมคือหน้าข้อมูลและวัตถุ พวกเขาตรวจสอบรูปแบบและให้ตัวอย่างทั้งแนวคิดและในชีวิตจริงแก่คุณ เอกสารอ้างอิงของพวกเขาก็ยอดเยี่ยมเช่นกัน

ไฟล์ฟังก์ชั่นเป็นตัวช่วยที่ให้ความบันเทิงในการขยายฟังก์ชันการทำงานของเว็บไซต์! โดยเฉพาะอย่างยิ่งหากใช้เพื่อวัตถุประสงค์ที่ตั้งใจไว้ อย่างไรก็ตาม เจ้าของบล็อก/เว็บไซต์จำนวนมากได้เปลี่ยน Functions.php ให้กลายเป็นส่วนรวมอย่างน่าอัศจรรย์

ในธุรกิจใดๆ ก็ตาม มีเหตุผลและข้อจำกัดต่างๆ (ข้อจำกัด ซึ่งมักเป็นตรรกะ) ดังนั้นจึงเป็นการถูกต้องมากกว่าที่จะย้ายโค้ดปฏิบัติการบางส่วนที่ออกแบบมาเพื่อควบคุมพารามิเตอร์ของคอร์ WP (ไม่ใช่ธีม) ไปนอกเทมเพลต...

เมื่อพูดถึงการปรับปรุงฟังก์ชันการทำงานของเว็บไซต์ให้ทันสมัย ​​ในบทความ "ไม่มีปลั๊กอิน..." พวกเขาแนะนำให้ใส่บล็อกโค้ดทั้งหมดลงใน Functions.php ที่เป็นตำนานอย่างแน่นอน นี่ผิด!

มีเหตุผลมากกว่าที่จะถ่ายโอนส่วนขยายทางเทคนิคทั้งหมด (ไม่เกี่ยวข้องโดยตรงกับสไตล์เทมเพลต) ไปยังปลั๊กอินที่จัดระเบียบสำหรับการลงทะเบียน

มาสร้างมันกันเถอะ! และเราจะพูดถึงข้อดีข้อเสีย (ซึ่งมีน้อยกว่ามาก)...


ส่วนของบทความ:

วิธีสร้างปลั๊กอินของคุณเอง

ในข้อความด้านล่างเราจะได้เรียนรู้วิธีสร้างปลั๊กอินของคุณเองด้วยมือของคุณเอง: เราจะเข้าใจรายละเอียดและความแตกต่างทั้งหมด มาดูกันว่าข้อดีข้อเสียคืออะไร (มีข้อเสียน้อยกว่า!! และสิ่งเหล่านี้ไม่ใช่ข้อเสียเลย แต่เป็นข้อดีอย่างใดอย่างหนึ่งสำหรับผู้ดูแลระบบแต่ละคน)

ความแตกต่างระหว่างไฟล์ function.php และปลั๊กอินคืออะไร

เหตุใดโค้ดบางส่วนจึงควรย้ายโดยตรงไปยังฟังก์ชันการทำงานของไซต์ไปยังปลั๊กอินแยกต่างหาก

ไฟล์ฟังก์ชั่นนั้นเอง วัตถุประสงค์ และความสอดคล้องของมันไม่แตกต่างจากปลั๊กอิน (เพียงแค่ปลั๊กอินในธีม))! — หน้าที่หลักคือการตกแต่งเทมเพลตเฉพาะ (ที่ใช้งานอยู่) ด้วยฟังก์ชันที่มีประโยชน์

ตัวอย่างเช่น "การนำทาง" โดยที่เมนูของปุ่มได้รับการตกแต่งอย่างมีเหตุผลด้วย CSS ตามสไตล์ของธีมที่ใช้งานอยู่ - บางทีมันอาจจะถูกต้องกว่าถ้าปล่อยไว้ในรูทของเทมเพลต

ประโยชน์ของการแยกไฟล์ฟังก์ชั่นออกเป็นไฟล์แยกกันหรือปลั๊กอินแยกคืออะไร?

ตัวอย่างเช่นสิ่งที่ซ้ำซากที่สุด - คุณตัดสินใจเปลี่ยนเทมเพลต!? ...ผลก็คือ การพัฒนาฟังก์ชันทั้งหมดจะหายไป เนื่องจากโค้ดที่มีประโยชน์ทั้งหมดอยู่ในไฟล์ฟังก์ชัน (ฉันเคยเห็นไฟล์ขนาด 750kILO เช่นนี้)

แน่นอนคุณสามารถย้ายเอกสารประกอบของฟังก์ชั่นไปยังหัวข้อใหม่ได้ แต่บ่อยครั้งที่คุณไม่สามารถทำได้หากไม่มีการแก้ไขซึ่งใช้เวลานานมาก: ลิงและแรงงาน)

และนอกจากนั้น:

ลำดับการดาวน์โหลดไฟล์เว็บไซต์

โดยสังเขป: ลำดับการโหลดไฟล์ไซต์หลักในตัวอย่างของเรามีดังนี้ - ปลั๊กอินของไซต์ที่ใช้งานอยู่ (จากโฟลเดอร์ปลั๊กอิน) และเนื้อหาจะถูกโหลดเร็วขึ้นเล็กน้อย จากนั้นจึงประมวลผลไฟล์ function.php ที่มีเนื้อหาเท่านั้น ทั้งหมดนี้เป็นมิลลิวินาทีและแทบจะไม่คุ้มค่าที่จะพูดถึงการเพิ่มความเร็วเพจอย่างจริงจัง

แม้ว่าดูเหมือนว่าเหตุผลประการหนึ่งสำหรับลำดับการโหลดนี้กำหนดโดยนักพัฒนาโดยที่ไฟล์ฟังก์ชันได้รับตำแหน่งที่สอง (เช่น คงจะองค์ประกอบที่เบากว่า) ซึ่งเป็นเพียงข้อเท็จจริงของการใช้ปลั๊กอินอย่างแพร่หลาย มักจะมีเนื้อหาจำนวนมาก...

บางคนจะอุทาน: ปลั๊กอินอื่น...? มันยาก!

และฉันบอกว่าสิ่งนี้จะไม่ส่งผลกระทบต่อความเร็วใดๆ... แต่ในทางกลับกัน หากคุณเข้าใกล้การสร้างเว็บไซต์อย่างรอบคอบ

นอกจากนี้ประโยชน์ของการโอนโค้ดบางส่วนยังเห็นได้ชัดในอีกทางหนึ่ง กล่าวคือ ความเร็วในการโหลดไซต์ไม่ได้ขึ้นอยู่กับจำนวนปลั๊กอินที่ใช้งานอยู่ แต่ขึ้นอยู่กับเนื้อหาด้วย! แล้วทำไมไม่ลดไฟล์ฟังก์ชั่นที่อย่างที่บอกไปโหลดทีหลังหน่อยล่ะ..? และยิ่งไปกว่านั้น มันเป็นปลั๊กอินระดับเทมเพลตขนาดใหญ่ที่เต็มเปี่ยม! แล้วโค้ดส่วนใหญ่ของเขาไปอยู่ที่ไหน?

ในความคิดของฉัน เทมเพลต (ใช้งานอยู่และใช้งานได้) ควรมีเฉพาะพารามิเตอร์ที่เกี่ยวข้องโดยเฉพาะเท่านั้น

เที่ยวคณิตศาสตร์...

  1. ถูกโหลดในภายหลัง คำถามคือ ทำไมไม่ย้ายไปยังสถานที่ที่ประมวลผลโค้ดเป็นหลัก และด้วยเหตุนี้ การแก้ไขพารามิเตอร์หลัก WP ที่ระบุโดยผู้ดูแลระบบจะถูกอ่านเร็วขึ้นและประมวลผลในขั้นตอนที่เหมาะสมของไซต์ ปล่อย?
  2. ความได้เปรียบอันฉาวโฉ่และการจัดระเบียบเชิงตรรกะของฟังก์ชันการทำงานของไซต์
  3. ความสะดวกสบายซึ่งไม่สำคัญ!

นอกจากนี้ ตามที่กล่าวไว้ ไฟล์ฟังก์ชันเป็นปลั๊กอินเดียวกัน - ฉันจะถามอีกครั้งว่าทำไมต้องยัดทุกอย่างลงไป? และในขณะที่ทำงานกับไซต์ คุณจะสับสนกับเอกสารโค้ดขนาดใหญ่ที่อ่านยาก ซึ่งในทางกลับกัน เนื้อหาในนั้นเต็มไปด้วยความเหลือเชื่อและไม่มีเหตุผล

การสร้างปลั๊กอินน้ำหนักเบานั้นง่ายและสมเหตุสมผลมากกว่า ตั้งค่าและลืมมันไปได้เลย...

ทุกคนตัดสินใจด้วยตัวเองว่าจะฟังประสบการณ์ของตนเองหรือความคิดเห็นของผู้เขียนบทความทางการศึกษาบางเรื่อง

ในขณะที่เราควรศึกษา 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 ซม. " "

แพลตฟอร์มปลั๊กอินถูกนำมาใช้ในกรอบงานพร้อมกับแอปพลิเคชัน "บล็อก" ดังนั้นสำหรับการศึกษาเพิ่มเติม เราแนะนำให้ติดตั้งแอปพลิเคชันนี้และตรวจสอบปลั๊กอินที่เขียนขึ้นสำหรับมัน (ปลั๊กอินได้รับการติดตั้งผ่าน "ตัวติดตั้ง") บล็อกมีการเขียนปลั๊กอินประเภทต่างๆ และแอปพลิเคชันที่ใช้งานได้จริง: สำหรับส่วนหน้า ส่วนหลัง การขยายความสามารถของอินเทอร์เฟซผู้ใช้ การอัปโหลดข้อมูล ฯลฯ