ส่วนที่ 2 – การเขียนโปรแกรม WordPress และ Object Oriented: ตัวอย่างในโลกแห่งความจริง

ในภาพรวมของ WordPress และการเขียนโปรแกรมเชิงวัตถุ เราได้ศึกษาทฤษฎีเบื้องหลังการเขียนโปรแกรมเชิงวัตถุ (OOP) และสิ่งที่คาดหวังเมื่อใช้งาน

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

สถานการณ์ในชีวิตจริง: การส่ง SMS

นี่เป็นเหมือนสถานการณ์ "อดีต" ในชีวิตที่จริงแล้ว SMS ถูกใช้น้อยลงในทุกวันนี้ แต่อย่างที่คุณเห็น มีเหตุผลที่เราใช้สิ่งนี้เป็นตัวอย่าง!

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

1. เตรียมข้อความ
2. เลือกหนึ่งในผู้ติดต่อของคุณและเพิ่มเป็นผู้รับ
3. ส่งข้อความ

ลองนึกภาพขั้นตอนที่คุณจะปฏิบัติตามเพื่อส่งข้อความของคุณ:

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

ตอนนี้ถ้าเราต้องแสดงรหัสแอปพลิเคชันที่ส่งข้อความ SMS เราควรวิเคราะห์ว่าควรติดตามเส้นทางใด กระบวนการหรือแนวทาง OOP

แอปพลิเคชันพร้อมแนวทางปฏิบัติ

หากคุณเป็นนักพัฒนาปลั๊กอิน WordPress คุณน่าจะคุ้นเคยกับ การเขียนโปรแกรมเชิงขั้นตอน

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

ในตัวอย่างของเราด้านบนที่มีข้อความ SMS คุณจะต้องดำเนินการต่างๆ ที่จะนำไปสู่ผลลัพธ์ที่ต้องการ ตามที่คุณอาจเดาได้อยู่แล้ว ตัวอย่างเช่น ตัวแปรที่เก็บเนื้อหาข้อความของข้อความ ฟังก์ชันที่มีพารามิเตอร์ $contact ที่ส่งคืนหมายเลขโทรศัพท์ และสุดท้ายคือฟังก์ชันที่ส่งข้อความ ในโค้ดจะมีลักษณะดังนี้:

 function get_phone_number( $contact ) { // Code that finds the contact's number in the list of contacts return $phone_number; } function send_sms( $contact, $message ) { $phone_number = get_phone_number( $contact ); // Code that sends the message to this number print "Message Sent!"; }

และคุณจะใช้มันแบบนี้:

 $text = "Hello John"; function send_message( "John Doe", $text );

ดังนั้น คุณจะต้องทำชุดของงานที่จะนำคุณไปสู่ผลลัพธ์ที่ต้องการ

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

การขยายขอบเขตการใช้งานด้วยวิธีการแบบมีขั้นตอน

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

เมื่อส่งอีเมล คุณต้องใช้ที่อยู่อีเมลของผู้ติดต่อ ไม่ใช่หมายเลขโทรศัพท์ นอกเหนือจากนี้ เราจะต้องเพิ่มพารามิเตอร์ใน send_message() สุดท้ายที่จะสอดคล้องกับประเภทของเทคโนโลยีที่เราใช้ อีเมลหรือ SMS

รหัสที่เกี่ยวข้องอาจมีลักษณะดังนี้:

 function get_phone_number( $contact ) { // Code that finds the contact's number return $phone_number; } function get_email_address( $contact ) { // Code that finds the contact's email address return $email_address; } function send_sms( $contact, $message ) { $phone_number = get_phone_number( $contact ); // Code that sends the message to this number print "SMS Sent!"; } function send_email( $contact, $message ) { $email_address = get_email_address( $contact ); // Code that sends the email to this number print "Email Sent!"; } function send_message( $contact, $message, $technology ) { if ( $technology == "SMS") { send_sms( $phone_number, $message ); } else if ( $technology == "Email") { send_email( $email_address, $message ); } }

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

ข้อเสียของแนวทางปฏิบัติ

จะเกิดอะไรขึ้นถ้าเรามีข้อความหลายประเภท คำสั่ง if จะกลายเป็นเรื่องใหญ่ที่น่ารำคาญ และที่สำคัญที่สุด ถ้าคุณมีฟังก์ชันที่ใช้ฟังก์ชัน send_message() ในกรณีนั้น คุณจะต้องเพิ่มพารามิเตอร์ $technology ในฟังก์ชันเหล่านั้นทั้งหมดด้วย

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

โฮสต์เว็บไซต์ของคุณด้วย Pressidium

รับประกันคืนเงิน 60 วัน

ดูแผนของเรา

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

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

แอปพลิเคชันด้วยแนวทาง OOP

ตอนนี้ มาวิเคราะห์สถานการณ์เดียวกันกับข้างต้นด้วยวิธี OOP

อันดับแรก เราจะกำหนดว่าเรามีวัตถุอะไรที่นี่ ลักษณะใดที่แต่ละสิ่งมี และการกระทำที่กระทำ ลักษณะคือสิ่งที่ภายหลังจะเป็นคุณสมบัติและการกระทำของเราจะเป็นหน้าที่หรือวิธีการของเราตามที่เรียกใน OOP

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

 <?php /** * Plugin Name: Send Message */ interface MessagingCapable { public function send_message( $contact, $message ); } class Phone implements MessagingCapable { public function send_message( $contact, $message ) { print "You sent" . $message ; } } function say_hi( MessagingCapable $device, $contact, $message ) { $device->send_message( $contact, $message ); }

เราประกาศคลาส Phone ซึ่งใช้อินเทอร์เฟซ MessagingCapable ดังนั้นเราจึงต้องใช้วิธีการทั้งหมดที่ประกาศไว้ say_hi() ต้องการ 3 พารามิเตอร์:

1. อุปกรณ์ที่รองรับการส่งข้อความ
2. การติดต่อ
3. ข้อความ

ในการส่งข้อความจริง ๆ เราใช้ฟังก์ชันนี้ดังนี้:

 $phone = new Phone(); say_hi( $phone, "John Doe", "Hello John" );

เรากำลังสร้างวัตถุโดยการสร้างอินสแตนซ์ของคลาสโทรศัพท์และส่งผ่านเนื้อหาการติดต่อและข้อความ สิ่งนี้จะส่งออก:

 You sent "Hello John"

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

การขยายแอปพลิเคชันด้วยแนวทาง OOP

มาเพิ่มความสามารถในการส่งอีเมลด้วยเหมือนที่เราทำก่อนหน้านี้ตามขั้นตอน

ไม่ว่าอุปกรณ์จะเป็นแบบใด เราก็อยากจะใช้ say_hi() ในลักษณะเดียวกัน ดูโค้ดด้านล่าง:

 <?php /** * Plugin Name: Send Message */ interface MessagingCapable { public function send_message( $contact, $message ); } class Phone implements MessagingCapable { public function send_message( $contact, $message ) { print ('You sent a "' . $message . '" SMS to ' . $contact ); } } class Computer implements MessagingCapable { public function send_message( $contact, $message ) { print ('You sent a "' . $message . '" email to ' . $contact ); } } function say_hi( MessagingCapable $device, $contact, $message ) { $device->send_message( $contact, $message ); }

เมื่อเราใช้โค้ดนี้ เราจะหยิบอุปกรณ์มือถือเพื่อส่ง SMS และคอมพิวเตอร์เพื่อส่งอีเมล เราจะ:

 say_hi ( new Phone(), "John Doe", "Hello John" );

หรือ:

 say_hi ( new Computer(), "John Doe", "Hello John" );

ที่จะส่งออกว่า You sent a "Hello John" SMS to John Doe และ You sent a "Hello John" email to John Doe ตามลำดับ

ที่นี่เราเริ่มตรวจพบคุณสมบัติ OOP บางอย่างแล้ว เราแนะนำอินเทอร์เฟซโดยใช้อินเทอร์เฟซ MessagingCapable

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

PHP ไม่รองรับการสืบทอดหลายรายการ หมายความว่าคลาสไม่สามารถสืบทอดคุณสมบัติ/เมธอดของคลาสพาเรนต์หลายคลาสได้

แม้ว่าจะสามารถขยายได้เพียงคลาสเดียว แต่ก็สามารถใช้อินเทอร์เฟซได้หลายแบบ

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

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

 say_hi( new Computer(), "John", "Hi" );

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

เพื่อพยายามอธิบายให้ดีขึ้นว่าการขยายปลั๊กอินของคุณใน Object-Oriented Programming นั้นง่ายเพียงใด ให้ลองเพิ่มฟังก์ชันการทำงานเพิ่มเติม

เพิ่มฟังก์ชันการทำงานมากขึ้น

หากเราต้องการเพิ่มความสามารถในการท่องอินเทอร์เน็ต เราจะเพิ่มอินเทอร์เฟซพิเศษสำหรับอุปกรณ์ใดๆ ที่สามารถตอบสนองต่อความสามารถนี้ เช่น คอมพิวเตอร์ เป็นต้น

 interface InternetBrowsingCapable { public function visit_website( $url ); }

การใช้งานอินเทอร์เฟซนี้จะถูกเข้ารหัสดังนี้:

 class Computer implements MessagingCapable, InternetBrowsingCapable { public function send_message( $contact, $message ) { print ('You sent a "' . $message . '" email to ' . $contact ); } public function visit_website( $url ) { print ('You visited "' . $url ); } }

ดังนั้นในคลาส Computer ปัจจุบัน เราเพิ่งเพิ่มอินเทอร์เฟซพิเศษที่จะใช้งาน เนื่องจากคอมพิวเตอร์สามารถส่งข้อความและท่องอินเทอร์เน็ต และวิธีการ visit_website( $url )

 function visit_url( InternetBrowsingCapable $device, $url ) { $device->visit_website( $url ); }

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

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

 <?php /* * Plugin Name: Communication Plugin */ interface MessagingCapable { public function send_message( $contact, $message ); } interface InternetBrowsingCapable { public function visit_website( $url ); } class Phone implements MessagingCapable { public function send_message( $contact, $message ) { print 'You sent a "' . $message . '" SMS to ' . $contact; } } class Computer implements MessagingCapable, InternetBrowsingCapable { public function send_message( $contact, $message ) { print 'You sent a "' . $message . '" email to ' . $contact; } public function visit_website( $url ) { print 'You visited "' . $url; } } class Smartphone extends Phone implements InternetBrowsingCapable { public function visit_website( $url ) { print 'You visited "' . $url; } public function send_message( $contact, $message ) { parent::send_message( $contact, $message ); print ' from your smartphone'; } } function say_hi( MessagingCapable $device, $contact, $message ) { $device->send_message( $contact, $message ); } function visit_url( InternetBrowsingCapable $device, $url ) { $device->visit_website( $url ); }

คลาสสมาร์ทโฟนขยายคลาสพาเรนต์ของ Phone และใช้อินเทอร์เฟซ InternetBrowsingCapable นั่นหมายความว่าสามารถส่งข้อความและไปที่ URL ได้ ที่นี่ เราตรวจพบคุณสมบัติการสืบทอด กล่าวคือ เรามีลำดับชั้นของคลาส คลาสหลัก (โทรศัพท์) และคลาสย่อย (สมาร์ทโฟน)

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

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

 say_hi ( new Phone(), "John Doe", "Hello John" ); say_hi ( new Computer(), "John Doe", "Hello John" ); say_hi ( new Smartphone(), "John Doe", "Hello John" ); visit_url ( new Smartphone(), "https://www.pressidium.com" ); visit_url ( new Computer(), "https://www.pressidium.com" );

เพื่อความเข้าใจที่ดียิ่งขึ้นของแนวคิดทั้งหมด ให้ดูที่แผนภาพคลาสของโค้ดด้านบน

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

หากคุณต้องการดูการทำงานของฟีเจอร์การห่อหุ้มด้วย ให้ลองรวมคลาสผู้ติดต่อในสคริปต์ตัวอย่างข้างต้นที่เราให้ไว้ ชั้นเรียนจะมีลักษณะดังนี้:

 class Contact { private $name; private $phone_number; private $email_address; public function __construct( $name, $phone_number, $email_address ) { $this->name = $name; $this->phone_number = $phone_number; $this->email_address = $email_address; } public function get_name() { return $this->name; } public function get_phone_number() { return $this->phone_number; } public function get_email_address() { return $this->email_address; } }

โดยการออกแบบ วิธีการ __construct() จะถูกเรียกโดยอัตโนมัติเมื่อสร้างวัตถุ ตอนนี้เมื่อเราสร้างอินสแตนซ์คลาส Contact คอนสตรัคเตอร์จะถูกเรียกและตั้งค่าคุณสมบัติส่วนตัว จากนั้นเราใช้ "getters" ของเราซึ่งเป็นวิธี get_name() get_phone_number() และ get_email_address() เพื่อดึงค่าเหล่านี้

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

บทสรุป

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

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

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

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

ในบทความถัดไปของซีรีส์นี้ เราจะเห็นการใช้งานรูปแบบการเขียนโปรแกรมนี้โดยนำไปใช้กับปลั๊กอิน WordPress โดยเฉพาะอย่างยิ่ง เราจะสร้างสำเนาของปลั๊กอิน Limit Login Attempts เวอร์ชัน 1.7.1 ที่สร้างโดย Johan Eenfeldt แต่แปลงด้วยวิธีเชิงวัตถุให้มากที่สุด

ในระหว่างกระบวนการนี้ เราจะแยกย่อยโฟลว์ของปลั๊กอินและกำหนดข้อกำหนด ต่อจากนี้ไป เราจะลองใช้ความคิดแรกของเราเกี่ยวกับการออกแบบปลั๊กอิน และในขั้นตอนการใช้งาน เราจะเขียนโค้ด ในระหว่างขั้นตอนการใช้งาน เราจะทำ back'n'forths และออกแบบใหม่ หากจำเป็น เพื่อให้ได้ผลลัพธ์ที่ต้องการ

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

คลิกที่นี่เพื่ออ่านส่วนที่ 3 ใน Objected Oriented Programming Series

ดูสิ่งนี้ด้วย

• WordPress และการเขียนโปรแกรมเชิงวัตถุ – ภาพรวม