Fungsi
dan Kelas
Mendefinisikan Fungsi
Sendiri
Anda akan
mendefinisikan fungsi Anda sendiri. Anda akan menggunakan katakunci PHP function untuk menamai dan
mendefinisikan fungsi sendiri, dan memanggilnya bila diperlukan.
<?php
// fungsi_sendiri.php
// mendefinisikan fungsi
// untuk menghitung luas lingkaran
function hitungLuasLingkaran($radius) {
return pi() * $radius
* $radius;
}
// memanggil fungsi
// untuk lingkaran dengan radius 10
// hasil: "Luas lingkaran dengan radius 10 adalah
314.159265359"
echo "Luas lingkaran dengan radius 10 adalah " .
hitungLuasLingkaran(10);
?>
Menghindari Duplikasi Fungsi
Anda akan menguji
apakah sebuah fungsi telah didefinisikan atau belum. Anda akan menggunakan
fungsi PHP function_exists().
<?php
// uji_fungsi.php
// fungsi contoh
function fungsiAda() {
return false;
}
// menguji apakah fungsi ada
// hasil: "Function exists"
echo function_exists("fungsiAda") ? "Fungsi
Ada" :"Fungsi Tidak Ada";
// hasil: "Fungsi Tidak Ada"
echo function_exists("fungsiTidakAda") ? "Fungsi
Ada" :"Fungsi Tidak Ada";
?>
Mengakses Variabel Eksternal
dari Dalam Fungsi
Anda akan mengakses
sebuah variabel yang didefinisikan di luar tubuh fungsi. Anda akan menggunakan
katakunci global di dalam definisi
fungsi untuk mengimpor variabel dari skop global.
<?php
// impor_variabel.php
// mendefinisikan variabel di luar fungsi
$nama = "Susan";
// mengakses variabel dari dalam fungsi
function siapaAku() {
global $nama;
return $nama;
}
// memanggil fungsi
// hasil: "Susan"
echo siapaAku();
?>
Cara alternatif dalam
melakukan hal yang sama adalah dengan mengakses variabel menggunakan namanya
melalui array asosiatif spesial $_GLOBALS, seperti didemonstrasikan pada kode
berikut:
<?php
// impor_variabel2.php
// mendefinisikan variabel di luar fungsi
$nama = "Susan";
// mengakses variabel dari dalam fungsi
function siapaAku() {
return
$GLOBALS['nama'];
}
// memanggil fungsi
// hasil: "Susan"
echo siapaAku();
?>
Untuk melihat
demonstrasi detail dari skop variabel di dalam dan di luar sebuah fungsi,
perhatikan kode berikut:
<?php
// impor_variabel3.php
// mendefinisikan sebuah variabel di luar fungsi
$nama = "Jono";
// mendefnisikan sebuah fungsi untuk mengubah variabel
function siapaAku() {
// mengakses variabel
dari dalam fungsi
global $nama;
// memeriksa variabel
// hasil: "Saya
Jono di awal fungsi."
echo "Saya $nama
di awal fungsi.\n";
//
mendefinisikan-ulang variabel di dalam fungsi
$nama =
"Joni";
// memeriksa variabel
// hasil: "Saya
Joni di akhir fungsi."
echo "Saya $nama
di akhir fungsi.\n";
}
// memeriksa variabel
// hasil: "Saya Jono sebelum fungsi di jalankan."
print "Saya $nama sebelum fungsi di jalankan.\n";
// memanggil fungsi
echo siapaAku();
// memeriksa variabel
// hasil: "Saya Joni setelah fungsi dijalankan."
print "Saya $nama setelah fungsi dijalankan.\n";
?>
Menetapkan Nilai Default
Untuk Argumen Fungsi
Anda akan menetapkan
nilai default untuk satu atau lebih argumen fungsi.
<?php
// nilai_default_argumen_fungsi.php
// mendefinisikan fungsi
// dengan argumen-argumen default
function pesanPizza($crust, $topping,
$size="12") {
return "Anda memesan sebuah pizza dengan ukuran $size-inci dengan crust
$crust
dan topping:
" . implode(', ', $topping);
}
// memanggil fungsi tanpa argumen ketiga opsional
// hasil: "Anda memesan sebuah pizza dengan ukuran 12-inci
dengan
// crust tipis dan topping: cheese, anchovies"
echo pesanPizza("tipis", array("cheese",
"anchovies"));
?>
Memproses Daftar Argumen
Variabel
Di sini, Anda akan
menggunakan fungsi Anda untuk mendukung banyak argumen tak-tetap. Anda akan
menggunakan fungsi func_get_args()
untuk membaca daftar argumen dengan banyak tak-tetap.
<?php
// banyak_argumen_tak_tetap.php
// mendefinisikan sebuah fungsi
function suatuFungsi() {
// mendapatkan banyak
argumen yang dilewatkan
$bnykArgumen =
func_num_args();
// membaca semua
argumen
$argumen =
func_get_args();
// menampilkan tiap
argumen
print "Anda
mengirimku argumen-argumen berikut: ";
for ($x=0;
$x<sizeof($argumen); $x++) {
print
"\nArgumen $x: ";
// memeriksa apakah sebuah array dilewatkan
// beriterasi dan
menampilkan isi jika demikian
if
(is_array($argumen[$x])) {
print "
ARRAY ";
foreach ($argumen[$x] as
$indeks=>$elemen) {
print
" $indeks => $elemen ";
}
} else {
print "
$argumen[$x] ";
}
}
}
// memanggil fungsi dengan argumen-argumen yang berbeda
// menghasilkan: "Anda mengirimku argumen-argumen berikut:
// Argumen 0: merah
// Argumen 1: hijau
// Argumen 2: biru
// Argumen 3: ARRAY 0 => 4 1 => 5
// Argumen 4: kuning"
suatuFungsi("merah", "hijau",
"biru", array(4,5), "kuning");
?>
Fungsi PHP func_get_args() didesain secara
spesifik untuk fungsi yang menerima banyak argumen yang tak-tetap. Ketika
digunakna di dalam sebuah definisi fungsi, func_get_args()
akan menghasilkan sebuah array yang memuat semua argumen yang dilewatkan kepada
fungsi tersebut. Tiap argumen kemudian dapat diekstrak dan diproses menggunakan
loop for. Ingat bahwa daftar argumen dapat memuat campuran dari variabel skalar
dan array. Jadi, jika Anda tidak pasti masukan apa yang diharapkan, Anda perlu
memeriksa tipa dari tiap argumen sebelum memutuskan bagaimana memprosesnya.
Berikut adalah contohnya.
<?php
// uji_banyak_arg_tak_tetap.php
// mendefinisikan fungsi yang menerima
// banyak argumen dinamis
function hitungJumlah() {
$jum = 0;
// membaca daftar
argumen sebagai array
$argumen =
func_get_args();
// memproses daftar
argumen
// dan menambahkan
tiap argumen ke total sebelumnya
// jika ada argumen
yang merupakan sebuah array
// maka gunakan loop
untuk memprosesnya
for ($x=0;
$x<sizeof($argumen); $x++) {
if
(is_array($argumen[$x])) {
foreach
($argumen[$x] as $a) {
$jum +=
$a;
}
} else {
$jum +=
$argumen[$x];
}
}
return $jum;
}
// memanggil fungsi dengan 2 argumen skalar
// hasil: "Penjumlahan dari 1 dan 0 adalah 11."
echo "Penjumlahan dari 1 dan 0 adalah " .
hitungJumlah(1,10) . ".\n";
// memanggil fungsi dengan campuran dari
// 3 argumen skalar dan 1 array
// hasil: " Penjumlahan dari 1, 2, 5 dan 1 adalah 9."
echo "Penjumlahan dari 1, 2, 5 dan
1 adalah " . hitungJumlah(1, 2, array(5,1)) . ".\n";
?>
Menghasilkan Nilai Balik
Jamak dari Sebuah Fungsi
Di sini, Anda akan
menghasilkan satu atau lebih nilai balik dari sebuah fungsi. Anda perlu
menempatkan himpunan nilai balik yang diinginkan di dalam sebuah array.
<?php
// nilai_balik_jamak.php
// mendefinisikan fungsi
// yang menghasilkan lebih dari satu nilai balik
function getInfoUser() {
return array("RH
Sianipar", "Fukuoka", "rismon@jepang.domain.edu");
}
// mengekstrak daftar nilai balik ke dalam variabel-variabel
terpisah
// hasil: "Nama saya RH Sianipar dari Fukuoka.
// Hubungi saya di rismon@jepang.domain.edu"
list ($nama, $alamat, $email) = getInfoUser();
echo "Nama saya $nama dari $alamat. Hubungi saya di
$email";
?>
Memanipulasi Masukan dan
Keluaran Fungsi Dengan Referensi
Pada kasus ini, Anda
akan melewatkan argumen-argumen masukan kepada, atau menerima nilai-nilai balik
dari, sebuah fungsi menggunakan referensi. Untuk melewatkan argumen dengan
referensi, argumen dibubuhi prefiks simbol & pada definisi fungsi.
<?php
// manipulasi_referensi.php
// mendefinisikan sebuah fungsi
// yang mengubah variabel menggunakan referensi
function ubahHari(&$hari) {
$hari =
"Kamis";
return $hari;
}
// mendefinisikan sebuah variabel di luar fungsi
$hari = "Minggu";
// memeriksa variabel
// hasil: "Sebelum menjalankan ubahHari(), hari adalah
Minggu."
echo "Sebelum menjalankan ubahHari(), hari adalah
$hari.\n";
// melewatkan variabel dengan referensi
ubahHari($hari);
// memeriksa variabel
// hasil: "Setelah menjalankan ubahHari(), hari adalah
Thursday."
echo "Setelah menjalankan ubahHari(), hari adalah
$hari.";
?>
Untuk menghasilkan
nilai balik menggunakan referensi, Anda perlu membubuhi prefiks simbol &
pada kedua nama fungsi dan pemanggilan fungsi.
<?php
// manipulasi_referensi2.php
// mendefinisikan fungsi
// yang menghasilkan nilai balik dengan referensi
function &inkremenAngka() {
global $angka;
$angka++;
return $angka;
}
// define a variable outside the function
$angka = 0;
// memanggil fungsi
// menghasilkan nilai balik fungsi sebagai referensi
// hasil: "Angka adalah 1."
$nilaiBalik =& inkremenAngka();
echo "Angka adalah $nilaiBalik.\n";
// memanggil fungsi kembali function again
inkremenAngka();
// memeriksa referensi
// hasil: "Angka adalah 2."
echo "Angka adalah $nilaiBalik.\n";
?>
Menghasilkan Pemanggilan
Fungsi Secara Dinamis
Di sini, Anda akan
secara dinamis menghasilkan pemanggilan fungsi dari suatu variabel PHP. Anda
akan menggunakan kurung untuk menginterpolasi nama variabel dengan pemanggilan
fungsi.
<?php
// pemanggilan_dinamis.php
// fungsi contoh
function mainkanTrek($id) {
echo "Mainkan
trek $id";
}
// mendefinisikan variabel untuk operasi
$op = "mainkan";
// membuat nama fungsi dari variabel
$fungsi = $op . "Trek";
// memanggil fungsi
// hasil: "Mainkan trek 45"
$fungsi(45);
?>
Secara Dinamis
Mendefinisikan Fungsi
Di sini, Anda akan
mendefinisikan sebuah fungsi secara dinamis ketika fungsi lain dipanggil.
<?php
// dinamis_fungsi.php
// mendefinisikan fungsi
function cariMinyak() {
// mendefinisikan
fungsi bersarang
// fungsi ini menjadi
tersedia
// hanya ketika fungsi
luar telah dipanggil
function
mulaiTambang() {
echo "Mulai
menambang. Kita akan kaya!\n";
}
echo "Sumur
minyak ditemukan. Hati-hati jangan meledak!\n";
}
// menjalankan fungsi
// hasil: "Sumur minyak ditemukan. Hati-hati jangan
meledak!"
cariMinyak();
// hasil: "Mulai menambang. Kita akan kaya!"
mulaiTambang();
?>
Menciptakan Fungsi Rekursif
Di sini, Anda akan
melakukan pekerjaan rekursif. Anda akan menuliskan sebuah fungsi rekursif yang
dijalankan secara berulang sampai kondisi tertentu terpenuhi.
<?php
// fungsi_rekursif.php
// fungsi rekursif
// untuk menghitung faktorial
function hitungFaktorial($angka) {
// mendefinisikan
variabel untuk menampung hasil
static $hasil = 1;
// rekursif sampai
$angka menjadi 1
if ($angka > 1) {
$hasil = $hasil *
$angka;
$angka--;
hitungFaktorial($angka);
}
return $hasil;
}
// hasil: "Faktorial dari 5 adalah 120"
echo "Faktorial dari 5 adalah " . hitungFaktorial(5);
?>
Mendefinisikan Kelas Sendiri
Anda akan
mendefinisikan kelas Anda sendiri. Anda mendefinisikan sebuah kelas menggunakan
katakunci class, mengisinya dengan
properti dan metode. Setelah kelas diciptakan, Anda bisa menghasilkan objek
kelas tersebut menggunakan katakunci new.
<?php
// kelas_sendiri.php
// mendefinisikan kelas
// untuk komputer generik
class Generik {
// properti
public $cpu;
public $mem;
// metode untuk
menetapkan spesifikasi memori
public function
setMemori($nil) {
$this->mem =
$nil;
echo
"Menetapkan memori menjadi $nil MB...\n";
}
// metode untuk
menetapkan spesifikasi prosesor
public function
setCpu($nil) {
$this->cpu =
$nil;
echo
"Menetapkan prosesor menjadi \"$nil\"...\n";
}
// metode untuk menampilkan
konfigurasi
public function
getKonfigurasi() {
echo "Konfigurasi saat ini: $this->cpu CPU, $this->mem MB RAM\n";
}
}
// menciptakan sebuah objek kelas
$pcKu = new Generik;
// menetapkan prosesor dan memori
$pcKu->setCpu("Pentium I7");
$pcKu->setMemori(2048);
// menampilkan konfigurasi
// hasil: "Konfigurasi saat ini: Pentium I7 CPU, 2048 MB
RAM"
$pcKu->getKonfigurasi();
?>
Secara Otomatis Mengeksekusi
Inisialisasi Kelas
Anda akan secara
otomatis mengeksekusi beberapa statemen tertentu ketika sebuah instans (objek)
suatu kelas diciptakan atau dihancurkan. Anda akan menggunakan konstruktor
dan/atau destruktor kelas.
<?php
// konstruktor_destruktor.php
// mendefinisikan kelas
class kelasUji {
// konstruktor
function __construct()
{
echo
"Menjalankan konstruktor...\n";
}
// destruktor
function __destruct()
{
echo
"Menjalankan destruktor...\n";
}
}
// menciptakan sebuah objek
// hasil: "Menjalankan konstruktor..."
$uji = new kelasUji();
// kemudian menghancurkan objek
// hasil: "Menjalankan destruktor..."
unset($uji);
?>
Berikut adalah kode
yang menggunakan kelas untuk mengunci file dan untuk membuka kunci tersebut.
<?php
// konstruktor_destruktor2.php
// mendefinisikan kelas
// untuk secara manual mengimplementasikan
// penguncian file
class kunciFile {
// properti
private $file;
// konstruktor
public function
__construct($file) {
$this->file =
$file;
$this->kunci();
}
// metode untuk
menciptakan file terkunci
public function
kunci() {
// membersihkan
cache dari file
clearstatcache();
// memeriksa
jika file terkunci sudah ada
// jika belum,
ciptakan
// jika ada, coba
lagi dalam beberapa detik
echo "Mencoba
untuk mengunci file...\n";
if
(!file_exists($this->file . ".terkunci")) {
touch
($this->file . ".terkunci", time())
or
die("ERROR: Tidak bisa mengunci file!\n");
echo
"File terkunci!\n";
} else {
echo
"File terkunci ada, mencoba lagi dalam 2 detik...\n";
sleep(2);
$this->kunci();
}
}
// metode untuk
menulis data ke file terkunci
public function
tulis($data) {
// mencoba menulis
ke dalam file
// menampilkan
error jika tidak berhasil
echo "Mencoba
menulis file...\n";
if (!$fp =
fopen($this->file, "a+")) {
echo
"ERROR: Tidak dapat membuka file untuk menulis!\n";
return false;
}
if (!fwrite($fp,
$data)) {
echo
"ERROR: Tidak dapat menulis ke file!\n";
return false;
}
if
(!fclose($fp)) {
echo
"ERROR: Tidak dapat menutup file!\n";
}
echo "Data
berhasil ditulis ke dalam file!\n";
}
// destruktor
public function
__destruct() {
$this->batal_kunci();
}
// metode untuk
menghapus kunci
public function
batal_kunci() {
// menghapus kunci
echo "Membuka
kunci pada file...\n";
unlink ($this->file
. ".terkunci")
or
die("ERROR: Tidak bisa membuka kunci pada file!");
echo "Kunci
pada file telah dibatalkan!\n";
}
}
// menciptakan objek
// menetapkan file terkunci
$fl = new kunciFile("/tmp/data.txt");
// menuliskan data ke dalam file
$fl->tulis("Saya memandangmu sekarang!");
// menghapus kunci
unset($fl);
?>
Menderivasi Kelas Baru
Anda akan
menderivasi kelas baru dari kelas yang telah ada. Anda akan menggunakan
katakunci extends untuk menciptakan
sebuah kelas terderivasi yang mewarisi semua metode dan properti dari kelas
basis.
<?php
// derivasi_kelas.php
// mendefinisikan kelas basis
class Generik {
// properti
protected $cpu;
protected $mem;
// konstruktor
function __construct()
{
echo
"Menginisialisasi konfigurasi sistem...\n";
}
// metode untuk
menetapkan konfigurasi memori
public function
setMemori($nil) {
$this->mem =
$nil;
echo
"Menetapkan memori menjadi $nil MB...\n";
}
// metode untuk
menetapkan spesifikasi prosesor
public function
setCpu($nil) {
$this->cpu =
$nil;
echo
"Menetapkan prosesor menjadi \"$nil\"...\n";
}
// metode untuk
menampilkan konfigurasi terkini
public function getKonfigurasi()
{
echo
"Konfigurasi terkini: $this->cpu CPU, $this->mem MB RAM\n";
}
// destructor
public function
__destruct() {
echo
"Mede-inisialisasi konfigurasi sistem...\n";
}
}
// mendefinisikan kelas terderivasi
class Server extends Generik {
// mendefinisikan
properti lain
protected $disk;
// mendefinisikan
beberapa metode lain
function __construct()
{
// menjalankan konstruktor induk
parent::__construct();
}
// metode untuk
menetapkan spesifikasi disk drive
function setDisk($nil)
{
$this->disk =
$nil;
echo
"Menetapkan penyimpanan disk menjadi $nil GB...\n";
}
// metode untuk
menambah memori
function
tambahMemori($nil) {
$this->mem +=
$nil;
echo
"Menambah memori sebesar $nil MB \n";
}
//
mendefinisikan-ulang metode induk untuk menampilkan
// konfigurasi terkini
public function
getKonfigurasi() {
echo
"Konfigurasi sekarang: " . $this->cpu .
" CPU,
$this->mem MB RAM, " . $this->disk .
" GB daya simpan disk\n";
}
}
// menciptakan sebuah objek dari kelas terderivasi
$webServer = new Server;
// menggunakan metode-metode yang diwarisi dari kelas basis
$webServer->setMemori(2048);
$webServer->setCpu("Intel Pentium I7");
$webServer->setDisk(450);
// menggunakan metode yang didefinisikan pada kelas terderivasi
$webServer->tambahMemori(2048);
// menampilkan konfigurasi
// hasil: "Konfigurasi sekarang: Intel Pentium I7 CPU, 4096
MB RAM,
// 450 GB daya simpan disk"
$webServer->getKonfigurasi();
?>
Memeriksa Apakah Metode Atau
Kelas Telah Didefinisikan
Di sini, Anda akan
memeriksa apakah metode kelas atau kelas tertentu telah didefinisikan atau
belum. Anda akan menggunakan fungsi PHP class_exists()
untuk menguji eksistensi sebuah kelas.
<?php
// uji_eksistensi_kelas.php
// kelas uji
class kelasUji {
public function
__construct() {
return false;
}
}
// menguji apakan kelas ada atau tidak
// hasil: "Kelas Ada"
echo class_exists("kelasUji") ? "Kelas Ada"
: "Kelas Tidak Ada";
// hasil: "Kelas Tidak Ada"
echo class_exists("kelasTakUji") ? "Kelas
Ada" : "Kelas Tidak Ada";
?>
Kemudian, Anda akan
menggunakan fungsi method_exists()
untuk menguji eksistensi sebuah metode kelas.
<?php
// uji_eksistensi_metode.php
// kelas contoh
class Anjing {
public function
gonggong() {
echo "Guk guk
guk guk!";
}
}
// menciptakan objek kelas
$spaniel = new Anjing;
// menguji apakan metode ada
// menggunakan objek kelas
// hasil: "Metode Ada"
echo method_exists($spaniel, "gonggong") ?
"Metode Ada" : "Metode Tidak Ada";
// hasil: "Metode Tidak Ada"
echo method_exists($spaniel, "gukguk") ? "Metode
Ada" : "Metode Tidak Ada";
?>
Anda dapat pula
menggunakan fungsi is_callable()
untuk menguji eksistensi sebuah metode kelas menggunakan nama kelas
(menggantikan objek kelas).
<?php
// uji_eksistensi_metode2.php
// kelas contoh
class Anjing {
public function
gonggong() {
echo "Guk guk
guk guk!";
}
}
// menciptakan objek kelas
$spaniel = new Anjing;
// menguji apakan metode ada
// menggunakan nama kelas
// hasil: "Metode Ada"
echo is_callable(array("Anjing",
"gonggong")) ? "Metode Ada" :
"Metode Tidak Ada";
// hasil: "Metode Tidak Ada"
echo is_callable(array("Anjing", "gukguk"))
? "Metode Ada" : "Metode Tidak Ada";
?>
Untuk memeriksa
eksistensi sebuah metode di dalam suatu kelas dari dalam definisi kelas itu
sendiri, Anda bisa menggunakan konstruksi $this
yang dikombinasikan dengan method_exists()
atau is_callable().
<?php
// uji_eksistensi_metode3.php
// kelas contoh
class Kucing {
// memeriksa apakah
sebuah metode ada
// di dalam kelas
sendiri
public function
meonk() {
return
method_exists($this, "kucingMeonk");
}
}
// menciptakan objek kelas
$kucingGarong = new Kucing;
// menghasilkan false karena Kucing::kucingMeonk() tidak
didefinisikan
// hasil: "Lihat, Itu tidak seperti kucing garong!"
echo $kucingGarong->meonk() ? "Lihat, Itu tidak seperti
kucing garong" :
"Itu mirip sekali
dengan kucing garong!";
?>
Membaca Informasi Pada
Anggota Kelas
Anda akan
mendapatkan informasi tentang objek atau kelas tertentu, termasuk informasi
pada anggota kelas dan properti objek. Anda akan menggunakan fungsi PHP get_class(), get_parent_class(), get_class_methods(),
get_class_vars(), dan get_object_vars().
<?php
// informasi_anggota_kelas.php
// mendefinisikan kelas basis
class Anjing {
// mendefinisikan
beberapa properti
public $nama;
public $umur;
// mendefinisikan
beberapa metode
public function
__construct() {
echo
"Menciptakan seekor Anjing.\n";
}
public function
goyangEkor() {
echo
"Hmmm...Anjing ini bahagia sekali!.\n";
}
}
// mewarisi kelas
class Bloodhound extends Anjing {
// mendefinisikan
properti lain
public $warna;
// mendefinisikan
beberapa metode lain
public function cium()
{
echo "Anjing
ini dapat mencium makanan beberapa kilometer jauhnya\n";
}
public function
__destruct() {
echo "Menghancukan seekor
Anjing.\n";
}
}
// menciptakan objek dari kelas terderivasi
$anjingKu = new Bloodhound();
$anjingKu->nama = "Bleki";
$anjingKu->umur = 5;
$anjingKu->warna = "hitam";
// membaca nama kelas dari objek kelas
echo "Kelas: " . get_class($anjingKu) .
"\n";
// membaca nama kelas induk dari objek kelas
echo "Kelas Induk: " .
get_parent_class(get_class($anjingKu)) . "\n";
// membaca dan menampilkan daftar properti kelas
$arrVar = get_class_vars(get_class($anjingKu));
echo "Properti-properti kelas: ";
foreach ($arrVar as $kunci => $nilai) {
if (!isset($nilai)) {
$nilai = "<undef>"; }
echo
"$kunci=$nilai ";
}
echo "\n";
// membaca dan menampilkan daftar metode objek
$arrMetode = get_class_methods(get_class($anjingKu));
echo "Metode-metode kelas: ";
foreach ($arrMetode as $m) {
echo "$m ";
}
echo "\n";
// membaca dan menampilkan daftar properti objek
$arrVar = get_object_vars($anjingKu);
echo "Properti-properti objek: ";
foreach ($arrVar as $kunci => $nilai) {
if (!isset($kunci)) {
$nilai = "<undef>"; }
echo
"$kunci=$nilai ";
}
echo "\n";
?>
Membaca Informasi Pada
Anggota Kelas
Cara alternatif
dalam mendapatkan informasi yang sama adalah dengan menggunakan refleksi, salah
satu fitur terbaru dalam PHP. Refleksi menyederhanakan mekanisme dalam
mendapatkan informasi detil tentang konstanta, properti, dan antarmuka kelas.
Cara termudah dalam mendapatkan informasi kelas dengan refleksi adalah dengan
menginisialisasi sebuah objek dari kelas ReflectionClass.
<?php
// informasi_anggota_kelas2.php
// mendefinisikan kelas basis
class Anjing {
// beberapa properti
public $nama;
public $umur;
// beberapa metode
public function
__construct() {
echo
"Menciptakan seekor Anjing.\n";
}
public function
goyangEkor() {
echo "Anjing
ini bahagia sekali!.\n";
}
}
// menggunakan refleksi untuk menginspeksi kelas
Reflection::export(new ReflectionClass('Anjing'));
?>
Atau, Anda dapat
menggunakan metode getConstants(), getMethods(), dan getProperties() dari kelas ReflectionClass
untuk mendapatkan informasi tentang konstanta, metode, dan properti kelas.
<?php
// informasi_anggota_kelas3.php
// mendefinisikan kelas basis
class Anjing {
// beberapa properti
public $nama;
public $umur;
// beberapa metode
public function
__construct() {
echo
"Menciptakan seekor Anjing.\n";
}
public function
goyangEkor() {
echo "Anjing
ini bahagia sekali!.\n";
}
}
// menggunakan refleksi untuk menginspeksi kelas
$reflektor = new ReflectionClass('Anjing');
// daftar konstanta
echo "Daftar konstanta: ";
foreach ($reflektor->getConstants() as $kunci => $nilai) {
echo
"$kunci=$nilai ";
}
echo "\n";
// daftar properti
echo "Daftar properti: ";
$arrVar = $reflektor->getProperties();
foreach ($arrVar as $obj) {
echo
$obj->getName() . " ";
}
echo "\n";
// daftar metode
echo "Daftar metode: ";
$arrMetode = $reflektor->getMethods();
foreach ($arrMetode as $obj) {
echo $obj->getName()
. " ";
}
echo "\n";
?>
Menampilkan Properti Dari
Objek
Di sini, Anda akan
menampilkan nilai terkini dari tiap properti objek. Anda menggunakan loop foreach untuk beriterasi pada tiap
properti objek, dan menampilkan isinya menggunakan echo.
<?php
// tampil_properti.php
// mendefinisikan kelas class
class Anjing {
// beberapa properti
public $varietas;
public $nama;
public $umur;
// metode
public function
__construct() {
echo
"Menciptakan seekor Anjing.\n";
}
}
// menciptakan objek
$objekAnjing = new Anjing();
$objekAnjing->nama = "Putih";
$objekAnjing->varietas = "Bloodhound";
$objekAnjing->umur = 7;
// beriterasi pada properti-properti objek
// menampilkan tiap properti dan nilai terkininya
foreach ($objekAnjing as $kunci => $nilai) {
echo "$kunci:
$nilai\n";
}
?>
Memeriksa Objek Suatu Kelas
Di sini, Anda akan
mengetahui apakah objek merupakan sebuah instans (objek) dari kelas tertentu.
Anda akan menggunakan operator PHP instanceof
dan fungsi PHP is_subclass().
<?php
// periksa_objek.php
// mendefinisikan kelas basis
class Anjing {
// kode tertentu
}
// mewarisi kelas
class Bloodhound extends Anjing {
// kode tertentu
}
// menciptakan instans (objek)
$spike = new Bloodhound;
// menghasilkan true
// hasil: "$spike adalah instans dari Bloodhound"
echo ($spike instanceof Bloodhound) ? "\$spike adalah
instans
dari Bloodhound" : "\$spike bukan instans dari
Bloodhound";
// menghasilkan true
// hasil: "$spike adalah subkelas dari Anjing"
echo is_subclass_of($spike, "Anjing") ? "\$spike
adalah subkelas dari
Anjing" : "\$spike bukan subkelas dari Anjing";
?>
Membandingkan Kesamaan Objek
Di sini, Anda akan
membandingkan dua objek untuk memeriksa apakah keduanya objek dari kelas yang
sama dan memiliki nilai dan properti yang sama. Anda akan menggunakan operator
PHP ==.
<?php
// banding_objek.php
// kelas contoh
class Sesi {
public $id;
function
__construct($id) {
$this->id =
$id;
}
}
// menciptakan tiga objek
$klienA = new Sesi(100);
$klienB = new Sesi(100);
$klienC = new Sesi(200);
// membandingkan dua objek menggunakan operator ==
// hasil: "true"
echo ($klienA == $klienB) ? "true" :
"false";
// membandingkan dua objek menggunakan operator ==
// hasil: "false"
echo ($klienA == $klienC) ? "true" :
"false";
?>
Operator PHP ==
menghasilkan true jika kedua objek yang dibandingkan merupakan objek-objek dari
kelas yang sama dan memiliki pasangan-pasangan properti-nilai yang sama.
Untuk menguji apakah
dua variabel PHP merujuk ke objek yang sama, Anda bisa menggunakan operator
===.
<?php
// banding_variabel.php
// sample class
class Sesi {
public $id;
function
__construct($id) {
$this->id =
$id;
}
}
// menciptakan dua objek
$klienA = new Sesi(100);
$klienARef =& $klienA;
$klienB = new Sesi(100);
// membandingkan dua objek menggunakan operator ===
// hasil: "false"
echo ($klienA === $klienB) ? "true" :
"false";
// membandingkan objek dan referensinya menggunakan operator ===
// hasil: "true"
echo ($klienA === $klienARef) ? "true" :
"false";
?>
Menyalin Objek
Di sini, Anda akan
menciptakan sebuah salinan dari objek kelas. Anda akan menggunakan katakunci
PHP clone.
<?php
// salin_objek.php
// kelas contoh
class Anjing {
// properti
public $nama;
public $umur;
// metode
public function
getInfo() {
echo "Saya
$this->nama, berumur $this->umur tahun.\n";
}
}
// menciptakan objek kelas
$spaniel = new Anjing;
// menetapkan properti
$spaniel->nama = "Bleky";
$spaniel->umur = 6;
// menyalin objek
$salin = clone $spaniel;
// membaca properti
// hasil: "Saya bleky, berumur 6 tahun"
$salin->getInfo();
?>
Menyalin Objek
Katakunci clone memudahkan dalam menyalin sebuah
objek kelas. Semua properti dari objek awal dialihkan ke objek salinan.
Dengan mendefinisika
metode spesial _clone() di dalam
kelas, Anda dapat secara otomatis mengeksekusi beberapa statemen tertentu
ketika objek dari kelas tersebut disalin.
<?php
// salin_objek2.php
// kelas contoh
class Anjing {
// properti
public $nama;
public $umur;
// metode
public function
getInfo() {
echo "Saya
$this->nama, berumur $this->umur tahun.\n";
}
// metode ini
dijalankan pada saat operasi penyalinan
// mengubah sebuah
properti dari objek hasil penyalinan
public function
__clone() {
$this->nama .=
" (salin)";
}
}
// menciptakan objek kelas
$spaniel = new Anjing;
// menetapkan properti
$spaniel->nama = "Bleky";
$spaniel->umur = 6;
// membaca properti (asli)
// hasil: "Saya Bleky, berumur 6 tahun"
$spaniel->getInfo();
// objek hasil penyalinan
$salin = clone $spaniel;
// membaca properti (salin)
// hasil: "Saya Bleky (salin), berumur 6 tahun"
$salin->getInfo();
?>
Menciptakan Anggota Kelas
Statis
Anda akan
menciptakan sebuah properti atau metode kelas yang dapat dipakai tanpa perlu
terlebih dahulu menginstansiasi objek dari kelas tersebut. Anda perlu
menggunakan katakunci PHP static
pada properti atau metode terkait.
<?php
// anggota_statis.php
// kelas contoh
class Contoh {
// mendefinisikan
properti statis
static $kounterContoh
= 0;
// konstruktor
// menginkremen ID
setiap kali sebuah
// objek baru
diciptakan
public function
__construct() {
echo
"Menciptakan objek baru...\n";
self::$kounterContoh++;
}
// metode untuk
menghasilkan ID objek terkini
public function
getkounterContoh() {
return
self::$kounterContoh;
}
}
// menciptakan dua objek
$a = new Contoh;
$b = new Contoh;
// membaca nilai kounter
// hasil: "Ada 2 objek yang diciptakan"
echo "Ada " . $a->getkounterContoh() . " objek
yang diciptakan\n";
// hasil salah: "Ada objek yang diciptakan"
echo "Ada " . $a->kounterContoh . " objek yang
diciptakan\n";
?>
Berikut adalah kode
untuk menciptakan metode kelas statis.
<?php
// metode_statis.php
// kelas contoh
class Benang {
// mendefinisikan
metode statis
public static function
pabrik() {
return new Benang;
}
// konstruktor
// private, sehingga
ia tak bisa dipanggil
// secara langsung
private function
__construct() {
echo
"Menciptakan Benang...\n";
}
}
// menciptakan sebuah objek kelas
$benang = Benang::pabrik(); // benar
$benang = new Benang(); // salah, menghasilkan error fatal
?>
Mengubah Visibilitas Anggota
Kelas
Di sini, Anda akan
membatasi metode dan/atau properti tertentu dari pengaksesan melalui objek
kelas atau dari objek kelas terderivasi. Anda menggunakan katakunci public, private, dan protected
untuk mendefinisikan level aksesibilitas (visibilitas) metode dan properti
kelas.
<?php
// visibilitas_anggota_kelas.php
// kelas contoh
class kelasUji {
// properti
public $varPublik;
private $varPrivate;
protected
$varProtected;
// metode
public function
metodePublik() { return; }
private function
metodePrivate() { return; }
protected function
metodeProtected() { return; }
}
// menciptakan objek kelas
$objekKelas = new kelasUji;
// mencoba untuk menetapkan properti
$objekKelas->varPublik = 255; // OK
$objekKelas->varPrivate = false; // ERROR
$objekKelas->varProtected = "Alamat email"; //
ERROR
// mencoba untuk menjalankan metode
$objekKelas->metodePublik(); // OK
$objekKelas->metodePrivate(); // ERROR
$objekKelas->metodeProtected(); // ERROR
?>
Membatasi Pewarisan Kelas
Di sini, Anda akan
melakukan pembatasan pada pewarisan kelas, misalnya, Anda akan memaksakan
beberapa metode tertentu agar selalu didefinisikan pada kelas-kelas anak, atau
Anda akan mencegah beberap kelas atau metode tertentu agar tidak bisa diwarisi.
Anda akan
menggunakan katakunci final untuk
mencega metode (atau kelas) agar tidak bisa diwarisi.
<?php
// katakunci_final.php
// mendefinisikan kelas
final class Generik {
public function
__construct() {
echo
"Menginisialisasi konfigurasi sistem...\n";
}
}
// mewarisi kelas
// menyebabkan error fatal
// karena kelas Generik tidak dapat diwarisi
class Server extends Generik {
public function
__construct() {
parent::__construct();
}
}
?>
Anda akan
menggunakan kelas abstrak untuk mengharuskan semua metode yang ada pada kelas
abstrak harus didefinisikan di dalam kelas yang mewarisinya.
<?php
// kelas_abstrak.php
// mendefinisikan kelas abstrak
abstract class tambahMesin {
// mendefinisikan
metode-metode abstrak
abstract public
function tambah();
abstract public
function kurang();
}
// mengimplementasikan kelas abstrak
// menghasilkan error fatal
// karena definisi tidak mencantumkan
// definisi metode tambah() dan kurang()
class Kalkulator extends tambahMesin {
// konstruktor
public function
__construct ($a, $b) {
$this->a = $a;
$this->b = $b;
}
}
?>
Mengoverload Metode Kelas
Di sini, Anda akan
mengoverload sebuah metode kelas sehingga ia dapat berperilaku berbeda
berdasarkan jumlah argumen atau tipe data yang dilewatkan kepadanya. Anda akan
mendefinisikan metode spesial __call()
di dalam kelas dan menggunakan statemen switch/case.
<?php
// overload_metode.php
// mendefinisikan kelas
class koordinatXY {
public $data;
public function
__construct($x, $y) {
$this->data =
array($x, $y);
}
}
// mendefinisikan kelas
class Pemetaan {
// mendefinisikan
metode teroverload
public function
__call($metode, $arg) {
// memeriksa nama metode
if ($metode ==
"peta") {
$jumArg =
count($arg);
//
mengeksekusi kode yang berbeda
// berdasarkan
jumlah argumen yang
// yang
dilewatkan
if ($jumArg ==
1) {
echo
"Pemetaan sebuah titik...\n";
} else if
($jumArg == 2) {
echo
"Pemetaan sebuah garis...\n";
} else if
($jumArg >= 3) {
echo "Pemetaan sebuah
poligon...\n";
} else {
die("ERROR: Data tak cukup\n");
}
} else {
die
("ERROR: Metode tak dikenal '$metode'\n");
}
}
}
// menciptakan objek
$r = new Pemetaan();
// memanggil metode dengan satu argumen
// hasil: "Pemetaan sebuah titik..."
$r->peta(new koordinatXY(1,2));
// memanggil metode dengan dua argumen
// hasil: "Pemetaan sebuah garis..."
$r->peta(new koordinatXY(1,2), new koordinatXY(20,6));
// memanggil metode dengan tiga argumen
// hasil: "Pemetaan sebuah poligon..."
$r->peta(new koordinatXY(1,2), new koordinatXY(20,6),
new koordinatXY(4,4), new koordinatXY(18,4));
?>
Adalah hal juga
memungkinkan untuk mengoverload sebuah metode sehingga ia merespon secara
berbeda terhadap pelbagai tipe data. Kode berikut mengilustrasikan hal ini,
yang mendefinisikan sebuah metode virtual balik()
melalui metode spesial __call() yang
membalik argumen yang disuplai. Berdasarkan apakah tipe argumen yang disuplai
adalah sebuah Boolean, string, angka, atau array, metode balik() akan membalikkan argumennya.
<?php
// overload_metode2.php
// mendefinisikan kelas
class kelasTeroverload {
// mendefinisikan
metode teroverload
public function
__call($metode, $arrArg) {
// memeriksa nama
metode
if ($metode ==
"balik") {
// memeriksa
jumlah argumen
if
(sizeof($arrArg) == 1) {
$arg =
$arrArg[0];
//
memeriksa tipa argumen
// dan
melakukan tugas yang cocok
if
(is_string($arg)) {
return
strrev($arg);
} else if
(is_numeric($arg)) {
return
1/$arg; // membalik angka
} else if
(is_array($arg)) {
return
array_reverse($arg);
} else if
(is_bool($arg)) {
return
($arg === FALSE) ? true : false;
} else if (is_null($arg)) {
return
null;
}
} else {
die
("ERROR: Jumlah argumen tak tepat\n");
}
} else {
die
("ERROR: Metode '$metode' tak dikenal\n");
}
}
}
// menciptakan objek
$o = new kelasTeroverload;
// mengeksekusi metode teroverload dengan pelbagai tipe data
echo $o->balik("aku") . "\n"; // hasil:
"uka"
echo $o->balik(true) . "\n"; // hasil: false
echo $o->balik(2) . "\n"; // hasil: 0.5
// hasil: ('h', 'a', 'b')
print_r($o->balik(array("b", "a",
"h"))) . "\n";
?>
Projek: Menghitung GCF (greatest commone
factor) dan LCM (least common
multiple)
Berikut adalah kode
untuk gcf_lcm.php:
<?php
// definisi fungsi
// mendapatkan GCF atas dua angka
function getGCF($a, $b) {
if ($b == 0) {
return $a;
}
else {
return getGCF($b,
$a % $b);
}
}
// definisi fungsi
// mendapatkan LCM atas dua angka menggunakan GCF
function getLCM($a, $b) {
return ($a * $b) /
getGCF($a, $b);
}
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0
Transitional//EN"
"DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xml:lang="en" lang="en">
<head>
<title>Projek:
GCF dan LCM</title>
</head>
<body>
<h2>Projek: GCF
dan LCM</h2>
<?php
// jika form belum disubmit form not yet submitted
// tampilkan form
if (!isset($_POST['submit'])) {
?>
<form
method="post" action="gcf_lcm.php">
Masukkan dua
integer: <br />
<input
type="text" name="angka_1" size="3" />
<p>
<input
type="text" name="angka_2" size="3" />
<p>
<input
type="submit" name="submit" value="Submit" />
</form>
<?php
// jika form telah disubmit
// proses masukan form
} else {
$angka1 =
(int)$_POST['angka_1'];
$angka2 =
(int)$_POST['angka_2'];
// menghitung dan
menampilkan GCF dan LCM
echo "Anda
memasukkan: $angka1, $angka2";
echo "<br
/>";
echo "GCF dari
($angka1, $angka2) = " . getGCF($angka1, $angka2);
echo "<br
/>";
echo "LCM dari
($angka1, $angka2) = " . getLCM($angka1, $angka2);
}
?>
</body>
</html>
Projek: Enkripsi Dan
Dekripsi Teks
Berikut adalah kode
untuk enkripsi.php:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xml:lang="en" lang="en">
<head>
<title>Projek:
Mengenkripsi Teks</title>
</head>
<body>
<h2>Projek:
Mengenkripsi Teks</h2>
<?php
// definisi kelas
class EnkripsiDekripsi {
// properti
public $kunci;
// metode
// menetapkan kunci
enkripsi
public function
setKunci($kunci) {
$this->kunci =
$kunci;
}
// mendapatkan kunci
enkripsi
public function
getKunci() {
return
$this->kunci;
}
// enkripsi
public function
enkripsi($plain) {
for ($x=0;
$x<strlen($plain); $x++) {
$cipher[] = ord($plain[$x]) + $this->getKunci() + ($x *
$this->getKunci());
}
return implode('/',
$cipher);
}
// dekripsi
public function
dekripsi($cipher) {
$data =
explode('/', $cipher);
$plain = '';
for ($x=0;
$x<count($data); $x++) {
$plain .= chr($data[$x] - $this->getKunci() - ($x *
$this->getKunci()));
}
return $plain;
}
}
?>
<?php
// jika form belum disubmit
// tampilkan form
if (!isset($_POST['submit'])) {
?>
<form
method="post" action="enkripsi.php">
Masukkan:
<input
type="radio" name="tipe" value="P"
checked>Plainteks</input>
<input
type="radio" name="tipe" value="C">Cipherteks
</input>
<br />
<textarea
name="teks" rows="6" cols="40"
wrap="soft"></textarea>
<p>
Masukkan kunci
numerik: <br />
<input
type="text" name="kunci" size="6" />
<p>
<input
type="submit" name="submit" value="Submit" />
</form>
<?php
// jika form telah disubmit
// proses masukan form
} else {
$tipe =
$_POST['tipe'];
$teks = $_POST['teks'];
$kunci =
(int)$_POST['kunci'];
// melakukan enkripsi
atau dekripsi
// print output
$j = new
EnkripsiDekripsi;
$j->setKunci($kunci);
if ($tipe == 'C') {
echo
$j->dekripsi($teks);
} else {
echo $j->enkripsi($teks);
}
}
?>
</body>
</html>
No comments:
Post a Comment