mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 17:41:41 +00:00
871 lines
22 KiB
Markdown
871 lines
22 KiB
Markdown
---
|
|
language: PHP
|
|
contributors:
|
|
- ["Malcolm Fell", "http://emarref.net/"]
|
|
- ["Trismegiste", "https://github.com/Trismegiste"]
|
|
filename: learnphp-id.php
|
|
translators:
|
|
- ["Ahmad Zafrullah", "https://github.com/23Pstars"]
|
|
- ["Cendy", "https://cendy.co"]
|
|
lang: id-id
|
|
---
|
|
|
|
Dokumen ini menjelaskan tentang PHP5 keatas.
|
|
|
|
```php
|
|
<?php // Skrip PHP harus diawali dengan tag <?php
|
|
|
|
// Jika dokumen PHP hanya mengandung kode PHP, sebaiknya tidak menggunakan
|
|
// tag penutup PHP untuk menghindari ketidaksengajaan tampilnya sesuatu.
|
|
|
|
// Dua garis miring diawal digunakan untuk komentar satu baris.
|
|
|
|
/*
|
|
Membatasi teks dalam garis miring-bintang dan bintang-garis miring
|
|
membuat komentar untuk banyak-baris sekaligus.
|
|
*/
|
|
|
|
// Gunakan "echo" atau "print" untuk menampilkan sesuatu
|
|
print('Halo '); // Menampilkan "Halo " tanpa baris baru
|
|
|
|
// () boleh tidak digunakan dalam menggunakan "print" dan "echo"
|
|
echo "Dunia\n"; // Menampilkan "Dunia" dengan baris baru
|
|
// (semua perintah harus diakhiri dengan titik koma)
|
|
|
|
// Apapun yang berada diluar tag <?php akan ditampilkan secara otomatis
|
|
?>
|
|
Halo Dunia, lagi!
|
|
<?php
|
|
|
|
|
|
/************************************
|
|
* Tipe Data & Variabel
|
|
*/
|
|
|
|
// Variabel diawali dengan simbol $.
|
|
// Nama variabel yang benar diawali dengan huruf atau garis-bawah,
|
|
// diikuti dengan beberapa huruf, angka, ataupun garis bawah.
|
|
|
|
// Nilai Boolean adalah case-insensitive
|
|
$boolean = true; // atau TRUE atau True
|
|
$boolean = false; // atau FALSE atau False
|
|
|
|
// Nilai Integer
|
|
$int1 = 12; // => 12
|
|
$int2 = -12; // => -12
|
|
$int3 = 012; // => 10 (awalan 0 menandakan bilangan Oktal)
|
|
$int4 = 0x0F; // => 15 (awalan 0x menandakan bilangan Heksadesimal)
|
|
// Bilangan Biner Integer tersedia mulai dari PHP 5.4.0.
|
|
$int5 = 0b11111111; // 255 (awalan 0b menandakan bilangan Biner)
|
|
|
|
// Nilai Floats (dikenal juga sebagai Doubles)
|
|
$float = 1.234;
|
|
$float = 1.2e3;
|
|
$float = 7E-10;
|
|
|
|
// Menghapus variable
|
|
unset($int1);
|
|
|
|
// Aritmatika
|
|
$jumlah = 1 + 1; // 2
|
|
$selisih = 2 - 1; // 1
|
|
$perkalian = 2 * 2; // 4
|
|
$pembagian = 2 / 1; // 2
|
|
|
|
// Aritmatika singkat
|
|
$angka = 0;
|
|
$angka += 1; // Menjumlahkan $angka dengan 1
|
|
echo $angka++; // Menampilkan 1 (dijumlahkan dengan 1 setelah dievaluasi)
|
|
echo ++$angka; // Menampilkan 3 (dijumlahkan dengan 1 sebelum dievaluasi)
|
|
$angka /= $float; // Membagi dan menyimpan hasil pembagian pada $angka;
|
|
|
|
// String biasanya diawali dan ditutup dengan petik satu.
|
|
$sgl_quotes = '$String'; // => '$String'
|
|
|
|
// Hindari menggunakan petik dua kecuali untuk menyertakan variabel lain
|
|
$dbl_quotes = "Ini adalah $sgl_quotes."; // => 'Ini adalah $String.'
|
|
|
|
// Karakter khusus hanya berlaku pada petik dua
|
|
$berfungsi = "Ini mengandung \t karakter tab.";
|
|
$tidak_berfungsi = 'Ini hanya mengandung garis miring dan huruf t: \t';
|
|
|
|
// Batasi variabel dengan kurung kurawal jika diperlukan
|
|
$uang = "Saya memiliki $${angka} di Bank.";
|
|
|
|
// Sejak PHP 5.3, nowdocs dapat digunakan untuk tak-terinterpolasi banyak-baris
|
|
$nowdoc = <<<'END'
|
|
Banyak baris
|
|
string
|
|
END;
|
|
|
|
// Heredocs akan melakukan interpolasi
|
|
$heredoc = <<<END
|
|
Banyak baris
|
|
$sgl_quotes
|
|
END;
|
|
|
|
// Menyambungkan String dapat dilakukan dengan menggunakan .
|
|
echo 'String ini ' . 'tersambung';
|
|
|
|
// Beberapa String dapat dijadikan sebagai parameter untuk "echo"
|
|
echo 'Banyak', 'Parameter', 'String'; // Menampilkan 'BanyakParameterString'
|
|
|
|
|
|
/********************************
|
|
* Konstan
|
|
*/
|
|
|
|
// Sebuah konstan didifinisikan menggunakan fungsi define()
|
|
// dan tidak bisa diganti/rubah selama program berjalan!
|
|
|
|
// Nama konstan yang benar diawali dengan huruf dan garis-bawah,
|
|
// diikuti dengan beberapa huruf, angka, ataupun garis-bawah.
|
|
define("FOO", "sesuatu");
|
|
|
|
// Mengakses konstan memungkinkan untuk dapat dipanggil tanpa menggunakan simbol $
|
|
echo FOO; // Menampilkan 'sesuatu'
|
|
echo 'Keluaran ini adalah ' . FOO; // Menampilkan 'Keluaran ini adalah sesuatu'
|
|
|
|
|
|
|
|
/********************************
|
|
* Larik (Array)
|
|
*/
|
|
|
|
// Semua larik dalam PHP bersifat asosiatif (saling berhubungan).
|
|
|
|
// Berfungsi pada semua versi PHP
|
|
$asosiatif = array('Satu' => 1, 'Dua' => 2, 'Tiga' => 3);
|
|
|
|
// Pada PHP 5.4 diperkenalkan cara penulisan (sintaks) baru
|
|
$asosiatif = ['Satu' => 1, 'Dua' => 2, 'Tiga' => 3];
|
|
|
|
echo $asosiatif['Satu']; // menampilkan 1
|
|
|
|
// Daftar literal secara tidak langsung ditentukan oleh kunci integer
|
|
$larik = ['Satu', 'Dua', 'Tiga'];
|
|
echo $larik[0]; // => "Satu"
|
|
|
|
// Menambahkan sebuah elemen pada akhir larik
|
|
$larik[] = 'Empat';
|
|
// atau
|
|
array_push($larik, 'Lima');
|
|
|
|
// Menghapus elemen dari larik
|
|
unset($larik[3]);
|
|
|
|
/********************************
|
|
* Keluaran
|
|
*/
|
|
|
|
echo('Halo Dunia!');
|
|
// Menampilkan Halo Dunia! ke "stdout".
|
|
// "stdout" adalah sebuah halaman web ketika dijalankan dalam peramban (browser).
|
|
|
|
print('Halo Dunia!'); // Sama seperti "echo"
|
|
|
|
// "echo" dan "print" merupakan bahasa konstruksi, jadi tanda kurung dapat dihilangkan
|
|
echo 'Halo Dunia!';
|
|
print 'Halo Dunia!';
|
|
|
|
$paragraf = 'paragraf';
|
|
|
|
echo 100; // Menampilkan variabel skalar secara langsung
|
|
echo $paragraf; // atau sebuat variabel
|
|
|
|
// Jika PHP tag-singkat telah dikonfigurasi, atau versi PHP yang digunakan
|
|
// adalah 5.4.0 keatas, dapat digunakan sintaks "echo" singkat
|
|
|
|
?>
|
|
<p><?= $paragraf ?></p>
|
|
<?php
|
|
|
|
$x = 1;
|
|
$y = 2;
|
|
$x = $y; // $x sekarang berisi nilai yang sama dengan $y
|
|
$z = &$y;
|
|
// $z sekarang berisi referensi ke $y. Mengubah nilai dari $z
|
|
// akan mengubah nilai dari $y juga, begitupun sebaliknya.
|
|
// $x tetap tidak berubah sebagaimana nilai asli dari $y
|
|
|
|
echo $x; // => 2
|
|
echo $z; // => 2
|
|
$y = 0;
|
|
echo $x; // => 2
|
|
echo $z; // => 0
|
|
|
|
// Menampilkan tipe dan nilai dari variabel ke "stdout"
|
|
var_dump($z); // prints int(0)
|
|
|
|
// Menampilkan variabel ke "stdout" dalam format yang mudah dibaca
|
|
print_r($larik); // menampilkan: Array ( [0] => Satu [1] => Dua [2] => Tiga )
|
|
|
|
/********************************
|
|
* Logika
|
|
*/
|
|
$a = 0;
|
|
$b = '0';
|
|
$c = '1';
|
|
$d = '1';
|
|
|
|
// assert akan melempar sebuah peringatan jika pernyataan tidak benar
|
|
|
|
// Perbandingan berikut akan selalu benar, meskipun memiliki tipe yang berbeda.
|
|
assert($a == $b); // kesamaan
|
|
assert($c != $a); // ketidak-samaan
|
|
assert($c <> $a); // versi lain dari ketidak-samaan
|
|
assert($a < $c);
|
|
assert($c > $b);
|
|
assert($a <= $b);
|
|
assert($c >= $d);
|
|
|
|
// Dibawah ini hanya akan bernilai benar jika nilainya memiliki tipe yang sama.
|
|
assert($c === $d);
|
|
assert($a !== $d);
|
|
assert(1 === '1');
|
|
assert(1 !== '1');
|
|
|
|
// Operator 'Spaceship' (sejak PHP 7)
|
|
// Mengembalikan 0 jika nilai pada kedua sisi adalah sama
|
|
// Mengembalikan 1 jika nilai pada sisi kiri lebih besar
|
|
// Mengembalikan -1 jika nilai pada sisi kanan lebih besar
|
|
|
|
$a = 100;
|
|
$b = 1000;
|
|
|
|
echo $a <=> $a; // 0 karena keduanya sama
|
|
echo $a <=> $b; // -1 karena $a < $b
|
|
echo $b <=> $a; // 1 karena $b > $a
|
|
|
|
// Variabel dapat dikonversi menjadi tipe lain, sesuai penggunaannya.
|
|
|
|
$integer = 1;
|
|
echo $integer + $integer; // => 2
|
|
|
|
$string = '1';
|
|
echo $string + $string; // => 2 (string dipaksa menjadi integer)
|
|
|
|
$string = 'satu';
|
|
echo $string + $string; // => 0
|
|
// Menghasilkan 0 karena operator (+) tidak dapat memaksa string 'satu' menjadi sebuah integer
|
|
|
|
// Perubahan tipe dapat dimanfaatkan untuk diperlakukan sebagai tipe lainnya
|
|
|
|
$boolean = (boolean) 1; // => true
|
|
|
|
$nol = 0;
|
|
$boolean = (boolean) $nol; // => false
|
|
|
|
// Terdapat juga fungsi khusus untuk melakukan perubahan terhadap beberapa tipe
|
|
$integer = 5;
|
|
$string = strval($integer);
|
|
|
|
$var = null; // Nilai Null
|
|
|
|
|
|
/********************************
|
|
* Struktur Kontrol
|
|
*/
|
|
|
|
if (true) {
|
|
print 'Saya tampil';
|
|
}
|
|
|
|
if (false) {
|
|
print 'Saya tidak tampil';
|
|
} else {
|
|
print 'Saya tampil';
|
|
}
|
|
|
|
if (false) {
|
|
print 'Tidak tampil';
|
|
} elseif(true) {
|
|
print 'Tampil';
|
|
}
|
|
|
|
// operator ternary
|
|
print (false ? 'Tidak tampil' : 'Tampil');
|
|
|
|
// cara pintas operator ternary mulai dirilis sejak PHP 5.3
|
|
// persamaan dari "$x ? $x : 'Kerjakan'"
|
|
$x = false;
|
|
print($x ?: 'Kerjakan');
|
|
|
|
// operator null coalesce sejak PHP 7
|
|
$a = null;
|
|
$b = 'Ditampilkan';
|
|
echo $a ?? 'a belum di-set'; // menampilkan 'a belum di-set'
|
|
echo $b ?? 'b belum di-set'; // menampilkan 'Ditampilkan'
|
|
|
|
|
|
$x = 0;
|
|
if ($x === '0') {
|
|
print 'Tidak ditampilkan';
|
|
} elseif($x == '1') {
|
|
print 'Tidak ditampilkan';
|
|
} else {
|
|
print 'Tampil';
|
|
}
|
|
|
|
|
|
// Alternatif sintaks untuk kebutuhan templat:
|
|
?>
|
|
|
|
<?php if ($x): ?>
|
|
Ini ditampilkan jika pengujian benar.
|
|
<?php else: ?>
|
|
Selain tersebut ini yang akan ditampilkan.
|
|
<?php endif; ?>
|
|
|
|
<?php
|
|
|
|
// Gunakan "switch" untuk menghemat logika.
|
|
switch ($x) {
|
|
case '0':
|
|
print 'Switch mendukung tipe paksaan';
|
|
break; // Kata kunci "break" harus disertakan, jika tidak
|
|
// maka logika tersebut akan berlanjut ke bagian "dua" dan "tiga"
|
|
case 'dua':
|
|
case 'tiga':
|
|
// Lakukan sesuatu jika $x bernilai "dua" atau "tiga"
|
|
break;
|
|
default:
|
|
// Aksi cadangan
|
|
}
|
|
|
|
// "while", "do...while" dan perulangan "for"
|
|
$i = 0;
|
|
while ($i < 5) {
|
|
echo $i++;
|
|
}; // Menampilkan "01234"
|
|
|
|
echo "\n";
|
|
|
|
$i = 0;
|
|
do {
|
|
echo $i++;
|
|
} while ($i < 5); // Menampilkan "01234"
|
|
|
|
echo "\n";
|
|
|
|
for ($x = 0; $x < 10; $x++) {
|
|
echo $x;
|
|
} // Menampilkan "0123456789"
|
|
|
|
echo "\n";
|
|
|
|
$roda = ['sepeda' => 2, 'mobil' => 4];
|
|
|
|
// Perulangan "foreach" dapat melakukan iterasi pada larik (array)
|
|
foreach ($roda as $jumlah_roda) {
|
|
echo $jumlah_roda;
|
|
} // Menampilkan "24"
|
|
|
|
echo "\n";
|
|
|
|
// Iterasi dapat dilakukan terhadap "key" (kunci) dan "value" (nilai)
|
|
foreach ($roda as $mesin => $jumlah_roda) {
|
|
echo "$mesin memiliki $jumlah_roda buah roda";
|
|
}
|
|
|
|
echo "\n";
|
|
|
|
$i = 0;
|
|
while ($i < 5) {
|
|
if ($i === 3) {
|
|
break; // Menghentikan proses perulangan
|
|
}
|
|
echo $i++;
|
|
} // Menampilkan "012"
|
|
|
|
for ($i = 0; $i < 5; $i++) {
|
|
if ($i === 3) {
|
|
continue; // Melewati tahapan iterasi saat ini
|
|
}
|
|
echo $i;
|
|
} // Menampilkan "0124"
|
|
|
|
|
|
/********************************
|
|
* Fungsi
|
|
*/
|
|
|
|
// Fungsi didefinisikan dengan "function":
|
|
function fungsi_saya () {
|
|
return 'Halo';
|
|
}
|
|
|
|
echo fungsi_saya(); // => "Halo"
|
|
|
|
// Nama fungsi yang baik dan benar diawali dengan sebuah huruf atau garis-bawah, diikuti oleh
|
|
// beberapa huruf, angka, atau garis-bawah.
|
|
|
|
function jumlah ($x, $y = 1) { // $y merupakan opsional, jika tidak ditentukan akan bernilai 1
|
|
$hasil = $x + $y;
|
|
return $hasil;
|
|
}
|
|
|
|
echo jumlah(4); // => 5
|
|
echo jumlah(4, 2); // => 6
|
|
|
|
// $hasil tidak dapat diakses dari luar fungsi
|
|
// print $hasil; // Akan menghasilkan sebuah "warning".
|
|
|
|
// Sejak PHP 5.3 fungsi dapat dideklarasikan menjadi tanpa-nama (anonymous);
|
|
$inc = function ($x) {
|
|
return $x + 1;
|
|
};
|
|
|
|
echo $inc(2); // => 3
|
|
|
|
function foo ($x, $y, $z) {
|
|
echo "$x - $y - $z";
|
|
}
|
|
|
|
// Fungsi dapat mengembalikan fungsi juga
|
|
function bar ($x, $y) {
|
|
// Gunakan "use" untuk mengakses variabel diluar fungsi
|
|
return function ($z) use ($x, $y) {
|
|
foo($x, $y, $z);
|
|
};
|
|
}
|
|
|
|
$bar = bar('A', 'B');
|
|
$bar('C'); // Menampilkan "A - B - C"
|
|
|
|
// Fungsi uang memiliki nama dapat dipanggil berdasarkan string
|
|
$nama_fungsi = 'jumlah';
|
|
echo $nama_fungsi(1, 2); // => 3
|
|
// Bermanfaat untuk menentukan fungsi mana yang akan dipanggil secara dinamis.
|
|
// Atau, dapat juga menggunakan fungsi call_user_func(callable $callback [, $parameter [, ... ]]);
|
|
|
|
// Akses semua parameter yang dikirim ke sebuah fungsi
|
|
function parameter() {
|
|
$jumlah_param = func_num_args();
|
|
if( $jumlah_param > 0 ) {
|
|
echo func_get_arg(0) . ' | ';
|
|
}
|
|
$daftar_param = func_get_args();
|
|
foreach( $daftar_param as $kunci => $param ) {
|
|
echo $kunci . ' - ' . $param . ' | ';
|
|
}
|
|
}
|
|
|
|
parameter('Halo', 'Dunia'); // Halo | 0 - Halo | 1 - Dunia |
|
|
|
|
// Sejak PHP 5.6, mendapatkan jumlah variabel yang ada pada parameter
|
|
function variabel($kata, ...$daftar) {
|
|
echo $kata . " || ";
|
|
foreach ($daftar as $item) {
|
|
echo $item . ' | ';
|
|
}
|
|
}
|
|
|
|
variable("Pemisah", "Halo", "Dunia") // Pemisah || Halo | Dunia |
|
|
|
|
/********************************
|
|
* Penyertaan ("include")
|
|
*/
|
|
|
|
<?php
|
|
// Skrip PHP yang berada dalam dokumen "include" juga harus dibuka dengan tag PHP.
|
|
|
|
include 'dokumen-saya.php';
|
|
// Kode yang ada dalam dokumen-saya.php sekarang dapat diakses dari cakupan saat ini.
|
|
// Jika dokumen tidak dapat disertakan (include, seperti dokumen tidak ditemukan), maka pesan peringatan akan muncul.
|
|
|
|
include_once 'dokumen-saya.php';
|
|
// Jika dokumen-saya telah disertakan (include) oleh perintah sebelumnya, maka
|
|
// dokumen tersebut tidak akan disertakan lagi. Ini bertujuan untuk menghindari kesalahan
|
|
// yang diakibatkan oleh deklarasi ganda.
|
|
|
|
require 'dokumen-saya.php';
|
|
require_once 'dokumen-saya.php';
|
|
// Memiliki fungsi yang sama dengan "include", namun jika dokumen tidak ditemukan
|
|
// atau tidak dapat disertakan maka akan menghasilkan pesan kesalahan fatal.
|
|
|
|
// Isi dari dokumen-saya.php:
|
|
<?php
|
|
|
|
return 'Apapun yang kamu suka.';
|
|
// akhir dari dokumen
|
|
|
|
// "include" dan "require" dapat mengembalikan sebuah nilai.
|
|
$nilai = include 'dokumen-saya.php';
|
|
|
|
// Dokumen akan disertakan berdasarkan lokasi direktori dokumen (file path) yang diberikan, jika tidak didefinisikan
|
|
// maka akan digunakan konfigurasi dari "include_path". Jika dokumen tidak ditemukan dalam "include_path",
|
|
// fungsi include akan melakukan pengecekan pada direktori yang sama dengan dokumen yang menggunakan fungsi include tersebut,
|
|
// jika tidak ditemukan juga maka pesan gagal akan dimunculkan.
|
|
/* */
|
|
|
|
/********************************
|
|
* Kelas (class)
|
|
*/
|
|
|
|
// Kelas didefinisikan dengan kata "class"
|
|
|
|
class KelasSaya
|
|
{
|
|
const NILAI_KONSTAN = 'nilai'; // Sebuah konstan
|
|
|
|
static $nilaiStatis = 'statis';
|
|
|
|
// Variabel statis dan hak jenis aksesnya
|
|
public static $variabelStatisPublik = 'nilaiStatisPublik';
|
|
// Hanya dapat diakses dalam kelas
|
|
private static $variabelStatisPrivat = 'nilaiStatisPrivat';
|
|
// Dapat diakses dalam kelas dan kelas turunan
|
|
protected static $variabelStatisTerlindungi = 'nilaiStatisTerlindungi';
|
|
|
|
// Properti harus mendeklarasikan hak aksesnya
|
|
public $properti = 'publik';
|
|
public $PropertiInstansi;
|
|
protected $terlindungi = 'terlindungi'; // Dapat diakses dari kelas itu sendiri dan kelas turunannya
|
|
private $terprivat = 'tersembunyi'; // Hanya dapat diakses dari kelas itu sendiri
|
|
|
|
// Membuat konstruktor dengan perintah __construct
|
|
public function __construct($PropertiInstansi) {
|
|
// Akses variabel instansi menggunakan perintah $this
|
|
$this->PropertiInstansi = $PropertiInstansi;
|
|
}
|
|
|
|
// Method dideklarasikan sebagai fungsi didalam kelas
|
|
public function methodSaya()
|
|
{
|
|
print 'KelasSaya';
|
|
}
|
|
|
|
// Perintah "final" membuat sebuah fungsi tidak dapat di-override oleh kelas turunannya
|
|
final function tidakDapatDiOverride()
|
|
{
|
|
}
|
|
|
|
// Metode ajaib
|
|
|
|
// apa yang dilakukan jika Objek diperlakukan sebagai String
|
|
public function __toString()
|
|
{
|
|
return $properti;
|
|
}
|
|
|
|
// Berlawanan dari __construct()
|
|
// Dipanggil saat objek tidak lagi di referensi
|
|
public function __destruct()
|
|
{
|
|
print "Destroying";
|
|
}
|
|
|
|
/*
|
|
* Deklarasi properti atau method pada kelas sebagai statis membuat properti atau method tersebut
|
|
* dapat diakses tanpa melakukan instansiasi kelas. Properti statis tidak dapat diakses melalui
|
|
* objek kelas yang hasil instansiasi, sedangkan method statis bisa.
|
|
*/
|
|
|
|
public static function methodStatisSaya()
|
|
{
|
|
print 'Saya adalah statis';
|
|
}
|
|
}
|
|
|
|
// Konstan pada kelas dapat diakses secara statis
|
|
echo KelasSaya::NILAI_KONSTAN; // Menampilkan 'nilai'
|
|
|
|
echo KelasSaya::$nilaiStatis; // Menampilkan 'statis'
|
|
KelasSaya::methodStatisSaya(); // Menampilkan 'Saya adalah statis'
|
|
|
|
// Instansi kelas menggunakan perintah "new"
|
|
$kelas_saya = new KelasSaya('Sebuah properti instansiasi');
|
|
// Tanda kurung adalah opsional jika tidak ingin menggunakan argumen.
|
|
|
|
// Akses anggota kelas menggunakan ->
|
|
echo $kelas_saya->properti; // => "publik"
|
|
echo $kelas_saya->propertiInstansi; // => "Sebuah properti instansi"
|
|
$kelas_saya->methodSaya(); // => "KelasSaya"
|
|
|
|
// Operasi Nullsafe semenjak PHP 8
|
|
// Kamu bisa menggunakan ini jika kamu tidak yakin apakah $kelas_saya memiliki sebuah properti/metode
|
|
// Ini bisa digunakan bersamaan dengan operator nullish coalesce untuk memastikan value
|
|
echo $kelas_saya->properti_invalid // Akan muncul sebuah error
|
|
echo $kelas_saya?->properti_invalid // => NULL
|
|
echo $kelas_saya?->properti_invalid ?? "publik" // => "publik"
|
|
|
|
// Menurunkan kelas menggunakan kata kunci "extends"
|
|
class KelasSayaLainnya extends KelasSaya
|
|
{
|
|
function tampilkanPropertiTerlindungi()
|
|
{
|
|
echo $this->terlindungi;
|
|
}
|
|
|
|
// "override" terhadap sebuah method
|
|
function methodSaya()
|
|
{
|
|
parent::methodSaya();
|
|
print ' > KelasSayaLainnya';
|
|
}
|
|
}
|
|
|
|
$kelas_saya_lainnya = new KelasSayaLainnya('Instansiasi properti');
|
|
$kelas_saya_lainnya->tampilkanPropertiTerlindung(); // => Menampilkan "terlindungi"
|
|
$kelas_saya_lainnya->methodSaya(); // Menampilkan "KelasSaya > KelasSayaLainnya"
|
|
|
|
final class SayaTidakBisaDiturunkan
|
|
{
|
|
}
|
|
|
|
// Gunakan method ajaib (magic method) untuk membuat fungsi "getters" dan "setters"
|
|
class PetaKelasSaya
|
|
{
|
|
private $properti;
|
|
|
|
public function __get($key)
|
|
{
|
|
return $this->$key;
|
|
}
|
|
|
|
public function __set($key, $value)
|
|
{
|
|
$this->$key = $value;
|
|
}
|
|
}
|
|
|
|
$x = new PetaKelasSaya();
|
|
echo $x->properti; // akan memanggil method __get()
|
|
$x->properti = 'Sesuatu'; // akan memanggil method __set();
|
|
|
|
// Kelas dapat dijadikan abstrak (menggunakan kata kunci "abstract"), atau
|
|
// meng-implementasikan interfaces (menggunakan kata kunci "implements").
|
|
// Sebuah interface dideklarasikan dengan perintah "interface".
|
|
|
|
interface InterfaceSatu
|
|
{
|
|
public function kerjakanSesuatu();
|
|
}
|
|
|
|
interface InterfaceDua
|
|
{
|
|
public function kerjakanYangLain();
|
|
}
|
|
|
|
// interface dapat diturunkan
|
|
interface InterfaceTiga extends InterfaceDua
|
|
{
|
|
public function kerjakanYangBerbeda();
|
|
}
|
|
|
|
abstract class KelasAbstrakSaya implements InterfaceSatu
|
|
{
|
|
public $x = 'kerjakanSesuatu';
|
|
}
|
|
|
|
class KelasKongkritSaya extends KelasAbstrakSaya implements InterfaceTwo
|
|
{
|
|
public function kerjakanSesuatu()
|
|
{
|
|
echo $x;
|
|
}
|
|
|
|
public function kerjakanYangLain()
|
|
{
|
|
echo 'kerjakanYangLain';
|
|
}
|
|
}
|
|
|
|
// Kelas dapat diimplementasikan pada banyak interface
|
|
class KelasLainnya implements InterfaceSatu, InterfaceDua
|
|
{
|
|
public function kerjakanSesuatu()
|
|
{
|
|
echo 'kerjakanSesuatu';
|
|
}
|
|
|
|
public function kerjakanYangLain()
|
|
{
|
|
echo 'kerjakanYangLain';
|
|
}
|
|
}
|
|
|
|
|
|
/********************************
|
|
* Sifat (Traits)
|
|
*/
|
|
|
|
// Traits mulai tersedia sejak PHP 5.4.0 dan dideklarasikan menggunakan kata kunci "trait"
|
|
|
|
trait TraitSaya
|
|
{
|
|
public function methodTraitSaya()
|
|
{
|
|
print 'Saya menggunakan Trait';
|
|
}
|
|
}
|
|
|
|
class KelasTraitSaya
|
|
{
|
|
use TraitSaya;
|
|
}
|
|
|
|
$kls = new KelasTraitSaya();
|
|
$kls->methodTraitSaya(); // menampilkan "Saya menggunakan Trait"
|
|
|
|
|
|
/********************************
|
|
* Namespaces
|
|
*/
|
|
|
|
// Bagian ini telah dibatasi, karena deklarasi "namespace"
|
|
// karena harus ditempatkan diawal dokumen.
|
|
|
|
<?php
|
|
|
|
// Secara default, kelas tersedia sebagai namespace umum, dan dapat
|
|
// secara khusus dipanggil dengan garis-miring terbalik (backslash).
|
|
|
|
$kls = new \KelasSaya();
|
|
|
|
|
|
// Menentukan namespace untuk sebuah dokumen
|
|
namespace Saya\Namespace;
|
|
|
|
class KelasSaya
|
|
{
|
|
}
|
|
|
|
// (dari dokumen lainnya)
|
|
$kls = new Saya\Namespace\KelasSaya;
|
|
|
|
// Atau dari dalam namespace lainnya.
|
|
namespace Saya\Lainnya\Namespace;
|
|
|
|
use Saya\Namespace\KelasSaya;
|
|
|
|
$kls = new KelasSaya();
|
|
|
|
// Namespace dapat menggunakan alias
|
|
|
|
namespace Saya\Lainnya\Namespace;
|
|
|
|
use Saya\Namespace as SuatuKelasLainnya;
|
|
|
|
$kls = new SuatuKelasLainnya\KelasSaya();
|
|
|
|
|
|
/**********************
|
|
* Late Static Binding
|
|
*
|
|
*/
|
|
|
|
class KelasInduk {
|
|
public static function siapa() {
|
|
echo "Ini adalah " . __CLASS__ . "\n";
|
|
}
|
|
public static function coba() {
|
|
// kata kunci "self" merujuk pada method yang berada dalam satu kelas
|
|
self::siapa();
|
|
// kata kunci "static" merujuk pada method yang berada di kelas dimana method itu dijalankan
|
|
static::siapa();
|
|
}
|
|
}
|
|
|
|
KelasInduk::coba();
|
|
/*
|
|
Ini adalah KelasInduk
|
|
Ini adalah KelasInduk
|
|
*/
|
|
|
|
class KelasAnak extends KelasInduk {
|
|
public static function siapa() {
|
|
echo "Tapi ini adalah " . __CLASS__ . "\n";
|
|
}
|
|
}
|
|
|
|
KelasAnak::coba();
|
|
/*
|
|
Ini adalah KelasInduk
|
|
Tapi ini adalah KelasAnak
|
|
*/
|
|
|
|
/**********************
|
|
* Magic constants
|
|
*
|
|
*/
|
|
|
|
// Mendapatkan nama dari suatu kelas. Harus dideklarasikan didalam kelas tersebut.
|
|
echo "Nama kelas ini adalah " . __CLASS__;
|
|
|
|
// Mendapatkan alamat lengkap direktori
|
|
echo "Alamat direktori ini adalah " . __DIR__;
|
|
|
|
// Beberapa yang banyak digunakan
|
|
require __DIR__ . '/vendor/autoload.php';
|
|
|
|
// Mendapatkan alamat lengkap dokumen
|
|
echo "Alamat dokumen ini adalah " . __FILE__;
|
|
|
|
// Mendapatkan nama fungsi
|
|
echo "Nama fungsi ini adalah " . __FUNCTION__;
|
|
|
|
// Mendapatkan nomor baris perintah
|
|
echo "Nomor baris perintah ini adalah " . __LINE__;
|
|
|
|
// Mendapatkan nama method. Hanya mengembalikan sebuah nilai jika berada didalam trait atau deklarasi objek.
|
|
echo "Nama method ini adalah " . __METHOD__;
|
|
|
|
// Mendapatkan nama namespace
|
|
echo "Namespace saat ini adalah " . __NAMESPACE__;
|
|
|
|
// Mendapatkan nama dari trait. Hanya mengembalikan sebuah nilai jika berada didalam trait atau deklarasi objek.
|
|
echo "Namespace saat ini adalah " . __TRAIT__;
|
|
|
|
/**********************
|
|
* Penanganan Kesalahan (Error)
|
|
*
|
|
*/
|
|
|
|
// Penanganan error sederhana menggunakan "try...catch"
|
|
|
|
try {
|
|
// Kerjakan sesuatu
|
|
} catch (Exception $e) {
|
|
// Penanganan exception
|
|
}
|
|
|
|
// Menggunakan "try...catch" blok pada namespace
|
|
|
|
try {
|
|
// Kerjakan sesuatu
|
|
} catch (\Exception $e) {
|
|
// Penanganan exception
|
|
}
|
|
|
|
// Exception khusus
|
|
|
|
class ExceptionSaya extends Exception {}
|
|
|
|
try {
|
|
|
|
$kondisi = true;
|
|
|
|
if ($kondisi) {
|
|
throw new ExceptionSaya('Terjadi sesuatu');
|
|
}
|
|
|
|
} catch (ExceptionSaya $e) {
|
|
// Penanganan untuk exception khusus
|
|
}
|
|
```
|
|
|
|
## Informasi lainnya
|
|
|
|
Kunjungi [Dokumentasi resmi PHP](http://www.php.net/manual/) untuk referensi dan masukan komunitas.
|
|
|
|
Jika anda tertarik untuk belajar lebih dalam, kunjungi
|
|
[PHP The Right Way](http://www.phptherightway.com/).
|
|
|
|
Jika anda terbiasa dengan manajemen paket, kunjungi
|
|
[Composer](http://getcomposer.org/).
|
|
|
|
Untuk standar umum, kunjungi PHP Framework Interoperability Group's
|
|
[PSR standards](https://github.com/php-fig/fig-standards).
|