Bagian 2 – WordPress dan Pemrograman Berorientasi Objek: Contoh Dunia Nyata

Diterbitkan: 2021-07-29

Dalam Ikhtisar WordPress dan Pemrograman Berorientasi Objek, kami membahas teori di balik Pemrograman Berorientasi Objek (OOP) dan apa yang diharapkan saat menggunakannya.

Sebelum melanjutkan dengan contoh pengkodean yang lebih spesifik menggunakan OOP, dalam artikel ini kami akan mencoba menjelaskan bagaimana skenario dunia nyata dapat didekati dengan pola pikir berbeda yang diperlukan untuk OOP dan bagaimana hal ini dianalisis menggunakan objek dan kelas.

Skenario Kehidupan Nyata: Mengirim SMS

Ini lebih seperti, skenario kehidupan "masa lalu" sebenarnya karena SMS semakin jarang digunakan saat ini tetapi seperti yang akan Anda lihat, ada alasan mengapa kami menggunakan ini sebagai contoh!

Misalkan Anda memiliki perangkat seluler dan ingin mengirim pesan teks ke salah satu kontak Anda. Menjaga contoh sesederhana mungkin, urutan tindakannya adalah:

Siapkan pesan
Pilih salah satu kontak Anda dan tambahkan sebagai penerima
Kirim pesan

Jadi mari kita coba dan visualisasikan langkah-langkah yang akan Anda ikuti untuk mengirim pesan Anda:

Kami menambahkan beberapa deskripsi tindakan yang lebih rinci tetapi kurang lebih semua yang Anda lakukan adalah 3 langkah dasar. Anda menyiapkan pesan di editor perangkat, Anda memilih penerima dari kontak Anda, lalu mengirim pesan. Dan Anda selesai! Pesan Anda sekarang terkirim.

Sekarang, jika kita merepresentasikan dalam kode aplikasi yang mengirim pesan SMS, kita harus menganalisis rute mana yang lebih baik untuk diikuti; pendekatan prosedural atau OOP.

Aplikasi dengan Pendekatan Prosedural

Jika Anda seorang pengembang plugin WordPress, kemungkinan besar Anda akrab dengan pemrograman prosedural .

Seperti yang kami jelaskan sebelumnya, pemrograman prosedural adalah jenis pemrograman imperatif, di mana program kami terdiri dari satu atau lebih prosedur. Jadi, sebagai pengembang, Anda memecah plugin Anda menjadi sekelompok variabel yang menyimpan data Anda, dan fungsi yang beroperasi pada data tersebut.

Dalam contoh kami di atas dengan pesan SMS, Anda akan melakukan serangkaian tindakan yang akan mengarah pada hasil yang diinginkan. Seperti yang mungkin sudah Anda duga, Anda akan memiliki, misalnya, variabel yang menyimpan konten teks pesan, fungsi dengan parameter $contact yang mengembalikan nomor telepon dan terakhir, fungsi yang mengirim pesan. Dalam kode akan terlihat seperti ini:

 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!"; }

Dan Anda akan menggunakannya seperti ini:

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

Jadi, Anda akan menyelesaikan serangkaian tugas yang akan membawa Anda ke hasil yang diinginkan.

Dalam contoh yang sangat sederhana ini tentu saja, yang memiliki persyaratan terbatas dan sangat spesifik, tidak ada alasan untuk mempertimbangkan menggunakan OOP sama sekali. Pemrograman prosedural lebih dari cukup untuk mencapai tujuan Anda. Namun, jika Anda memikirkan beberapa skenario tentang bagaimana aplikasi ini dapat berkembang di masa mendatang, Anda mungkin menyadari bahwa, dalam jangka panjang, Anda dapat memiliki masalah dalam hal skalabilitas. Kami akan mencoba dan menjelaskan alasannya di bawah ini.

Memperluas Aplikasi dengan Pendekatan Prosedural

Katakanlah Anda ingin meningkatkan aplikasi ini dan menyediakan kemampuan untuk mengirim pesan jenis lain juga, seperti email misalnya. Fungsi yang menyampaikan pesan akan berbeda dalam setiap kasus.

Saat mengirim email, Anda memerlukan alamat email kontak, bukan nomor telepon. Selain itu, kita perlu menambahkan parameter dalam fungsi send_message() akhir yang akan sesuai dengan jenis teknologi yang kita gunakan; email atau SMS.

Kode yang sesuai dapat terlihat seperti ini:

 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 ); } }

Jadi, bukannya tidak bisa dilaksanakan dengan pendekatan prosedural. Tetapi jika Anda seorang pengembang berpengalaman, Anda mungkin sudah mengerti bagaimana ini bisa menjadi berantakan di masa depan.

Kelemahan dengan Pendekatan Prosedural

Bagaimana jika kita memiliki beberapa jenis pesan? Pernyataan if akan menjadi sangat besar. Dan, yang terpenting, bagaimana jika Anda memiliki fungsi yang menggunakan fungsi send_message() ? Dalam hal ini, Anda juga perlu menambahkan parameter $technology di semua fungsi tersebut.

Saat kode Anda berkembang, fungsi akan ada di mana-mana yang berarti Anda akan mulai menyalin/menempelkan potongan kode (tidak pernah diinginkan), dan membuat perubahan kecil pada suatu fungsi dapat merusak beberapa fungsi lainnya. Kita semua pernah ke sana. Anda ingin menghindari ini dan dapat dengan mudah menambahkan fitur ke kode Anda tanpa terlalu banyak mengganggu struktur.

Pemrograman berorientasi objek (atau OOP) adalah paradigma pemrograman yang mencoba memecahkan masalah ini dengan memungkinkan kita untuk menyusun plugin kita menjadi potongan kode kecil yang dapat digunakan kembali, yang disebut class . Seperti yang kami jelaskan di artikel Ikhtisar OOP kami, kelas pada dasarnya adalah templat yang kami gunakan untuk membuat instance individual dari kelas, yang disebut objek .

Sebuah objek berisi data dan kode. Kami masih memiliki variabel yang dapat menyimpan informasi, yang disebut properti . Dan prosedur yang beroperasi pada data disebut metode .

Aplikasi dengan Pendekatan OOP

Sekarang mari kita analisis skenario yang sama seperti di atas dengan pendekatan OOP.

Pertama, kita akan mendefinisikan objek apa yang kita miliki di sini, karakteristik apa yang dimiliki masing-masing dan tindakan apa yang mereka lakukan. Karakteristiknya adalah apa yang nantinya akan menjadi properti kita dan tindakan akan menjadi fungsi atau metode kita seperti yang disebut di OOP.

Mari kita pikirkan apa yang kita miliki dalam skenario pertama mengirim SMS dengan cara yang paling sederhana. Ada perangkat yang memiliki antarmuka yang kita gunakan untuk mengirim pesan SMS. Kami memiliki konten pesan, kami memilih kontak sebagai penerima dan akhirnya pesan.

 <?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 ); }

Kami mendeklarasikan kelas Phone yang mengimplementasikan antarmuka MessagingCapable . Jadi kita harus mengimplementasikan semua metode yang dideklarasikan di dalamnya. Fungsi say_hi() membutuhkan 3 parameter:

Perangkat yang mendukung perpesanan
Sebuah kontak
Pesan

Untuk benar-benar mengirim pesan, kami menggunakan fungsi ini seperti ini:

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

Kami pada dasarnya membuat objek dengan membuat instance kelas Telepon dan meneruskan konten kontak dan pesan. Ini akan menghasilkan:

 You sent "Hello John"

Kami mendemonstrasikan skenario sederhana mengirim pesan teks dengan menggunakan kelas. Di bagian selanjutnya, kita akan melihat bagaimana kita dapat memperluas kemampuan aplikasi mengikuti pendekatan OOP dan saat meningkatkan, kita akan memeriksa di mana fitur OOP memainkan perannya serta manfaat menggunakan teknik ini.

Memperluas Aplikasi dengan pendekatan OOP

Mari tambahkan kemampuan untuk mengirim email juga, seperti yang kita lakukan sebelumnya secara prosedural.

Terlepas dari perangkatnya, kami idealnya ingin menggunakan fungsi say_hi() dengan cara yang sama. Perhatikan kode di bawah ini:

 <?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 ); }

Saat kami menggunakan potongan kode ini, kami akan mengambil perangkat seluler untuk mengirim SMS dan komputer untuk mengirim email. Kami akan:

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

atau:

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

yang akan menghasilkan You sent a "Hello John" SMS to John Doe dan You sent a "Hello John" email to John Doe .

Di sini kita sudah mulai mendeteksi beberapa fitur OOP. Kami memperkenalkan antarmuka dengan menggunakan antarmuka MessagingCapable .

Antarmuka mendeklarasikan satu set metode yang harus diimplementasikan oleh kelas tanpa mendefinisikan bagaimana metode ini diimplementasikan. Semua metode yang dideklarasikan dalam antarmuka harus bersifat publik.

PHP tidak mendukung pewarisan berganda, artinya suatu kelas tidak dapat mewarisi properti/metode dari banyak kelas induk.

Meskipun hanya dapat memperluas satu kelas, ia dapat mengimplementasikan banyak antarmuka.

Menggunakan Telepon untuk mengirim pesan akan berbeda dengan menggunakan Komputer. Instance dari kelas yang berbeda bertindak secara berbeda ketika diminta untuk melakukan tindakan yang sama (yaitu send_message() ). Ini adalah contoh Polimorfisme. Jika nanti kita membuat perangkat baru, kita tidak perlu mengubah kode kita untuk mengakomodasinya, selama semuanya berbagi antarmuka yang sama.

Kami juga ingin menunjukkan di sini bahwa kami juga telah melihat perbedaan dalam keterbacaan. Cara terakhir kita menggunakan script ini hanya dengan coding :

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

Ini benar-benar mudah bagi pengembang mana pun yang mengerjakan proyek tersebut. Dan tentu saja, semakin kompleks plugin, semakin jelas betapa bermanfaatnya ini, terutama ketika bekerja dalam tim.

Untuk mencoba dan menjelaskan dengan lebih baik betapa mudahnya memperluas plugin Anda di Pemrograman Berorientasi Objek, mari coba tambahkan beberapa fungsionalitas lagi.

Menambahkan Lebih Banyak Fungsi

Jika kita ingin menambahkan kemampuan untuk menjelajah internet, kita tinggal menambahkan antarmuka tambahan untuk perangkat apa pun yang dapat merespons kemampuan ini, seperti komputer misalnya.

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

Implementasi antarmuka ini akan dikodekan seperti ini:

 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 ); } }

Jadi di kelas Komputer saat ini kami baru saja menambahkan antarmuka tambahan untuk diimplementasikan, karena komputer dapat mengirim pesan dan menjelajahi internet, dan metode visit_website( $url ) .

CATATAN: Tentu saja, karena mengunjungi url sama sekali tidak relevan dengan fungsi say_hi() kami juga akan memperkenalkan fungsi baru, seperti:

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

Dan itu saja! Untuk perangkat apa pun yang dapat mengunjungi URL, kami dapat menggunakan fungsi ini seperti yang kami lakukan dengan komputer. Tidak ada kekhawatiran bahwa Anda akan merusak fungsionalitas lainnya. Ini menunjukkan skalabilitas yang tersedia saat menggunakan OOP dibandingkan dengan pemrograman prosedural.

Mari tambahkan perangkat smartphone hanya untuk mendemonstrasikan beberapa fitur lagi. Berikut adalah seluruh kode, dengan penambahan kelas ponsel cerdas sehingga Anda dapat memiliki gambaran yang lebih baik tentang apa yang terjadi:

 <?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 ); }

Kelas Smartphone memperluas kelas induk Telepon dan mengimplementasikan antarmuka InternetBrowsingCapable . Itu berarti dapat mengirim pesan dan mengunjungi URL. Di sini, kami mendeteksi fitur Warisan. Dengan kata lain, kami memiliki hierarki kelas, kelas induk (Telepon) dan subkelas (Smartphone).

Jadi objek Smartphone mewarisi semua properti dan perilaku dari kelas Telepon induk. Dengan begitu, di dalam kelas anak kita bisa menambahkan metode atau mengganti metode kelas induk, seperti yang kita lakukan dengan send_message() di kelas Smartphone. Kami melakukan ini untuk mengubah output. Kami benar-benar dapat mengabaikan metode ini dan menggunakan send_message() dari kelas induk apa adanya.

Anda dapat mencoba sendiri kodenya dengan menempelkannya di blok kode ke alat online PHP yang hebat ini. Di bawah kode, coba salah satu baris kode ini dan lihat hasil yang berbeda.

 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" );

Untuk pemahaman yang lebih baik tentang keseluruhan konsep, lihat diagram Kelas dari kode di atas.

Seperti yang digambarkan di atas, saat mendesain hubungan antar kelas, kami tidak menyertakan elemen umum di kelas anak. Selanjutnya, jangan lupa untuk memperhatikan panduan di sebelah kiri sehingga Anda dapat mengidentifikasi hubungan dan visibilitas properti dan metodenya.

Jika Anda ingin melihat fitur Enkapsulasi beraksi juga, coba dan sertakan kelas Kontak di salah satu skrip contoh di atas yang kami sediakan. Kelas akan terlihat seperti ini:

 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; } }

Metode __construct() , sesuai desain, dipanggil secara otomatis saat pembuatan objek. Sekarang ketika kita membuat instance kelas Kontak, konstruktornya dipanggil dan menetapkan nilai properti pribadinya. Kemudian kami menggunakan "getter" kami yaitu get_name() , get_phone_number() dan get_email_address() metode publik untuk mengambil nilai-nilai ini.

Enkapsulasi adalah bundling data dengan metode yang beroperasi pada data sementara membatasi akses langsung mencegah paparan rincian implementasi tersembunyi.

Kesimpulan

Semoga artikel ini membantu Anda memahami pemrograman Berorientasi Objek dengan cara yang lebih praktis. OOP sangat membantu mempermudah aplikasi untuk berkembang di masa depan jika perlu dengan menjadi jelas dan dapat digunakan kembali.

Selain itu plugin yang menggunakan OOP akan lebih cepat dan mudah untuk dieksekusi. Itu karena metode yang umum untuk semua objek kelas hanya menggunakan memori sekali, selama deklarasinya.

Keamanan juga ditingkatkan karena enkapsulasi. Dalam pemrograman prosedural di sisi lain, semua data bersifat global yang berarti akses tersedia dari mana saja.

Sebagai hasil dari hal di atas, pemeliharaan kode, produktivitas, skalabilitas, dan pemecahan masalah juga menjadi lebih mudah bagi Anda dan tim Anda.

Dalam artikel berikutnya dari seri ini kita akan melihat gaya pemrograman ini beraksi dengan menerapkannya ke plugin WordPress. Secara khusus, kami akan membuat salinan plugin Limit Login Attempts versi 1.7.1 yang dibuat oleh Johan Eenfeldt tetapi sebanyak mungkin dikonversi dengan pendekatan Berorientasi Objek.

Selama proses ini, kami akan memecah aliran plugin dan menetapkan persyaratannya. Ke depannya, kami akan mencoba pemikiran pertama kami tentang desain plugin dan, pada langkah implementasi, kami akan menulis kodenya. Selama proses implementasi, kami akan melakukan beberapa langkah mundur dan mendesain ulang, jika perlu, untuk mendapatkan hasil yang diinginkan.

Kami tidak akan membahas detail semua bagian kode. Sebagai gantinya, kami ingin fokus pada berbagi cara plugin dibangun dengan cara Berorientasi Objek. Kami yakin bahwa, setelah Anda selesai membaca seri artikel ini, Anda dapat membuat plugin OOP Anda sendiri dengan sangat baik.

Klik di sini untuk membaca Bagian 3 dalam Seri Pemrograman Berorientasi Objek kami

Lihat juga

WordPress dan Pemrograman Berorientasi Objek – Gambaran Umum