diff options
Diffstat (limited to 'id-id')
| -rw-r--r-- | id-id/json-id.html.markdown | 5 | ||||
| -rw-r--r-- | id-id/php-id.html.markdown | 848 | ||||
| -rw-r--r-- | id-id/ruby-id.html.markdown | 622 | ||||
| -rw-r--r-- | id-id/xml-id.html.markdown | 79 |
4 files changed, 1548 insertions, 6 deletions
diff --git a/id-id/json-id.html.markdown b/id-id/json-id.html.markdown index 52e61449..ca346f6c 100644 --- a/id-id/json-id.html.markdown +++ b/id-id/json-id.html.markdown @@ -1,11 +1,12 @@ --- language: json -filename: learnjson.json +filename: learnjson-id.json contributors: - ["Anna Harren", "https://github.com/iirelu"] - ["Marco Scannadinari", "https://github.com/marcoms"] -translators +translators: - ["Rizky Luthfianto", "https://github.com/rilut"] +lang: id-id --- JSON adalah format pertukaran data yang sangat simpel, kemungkinan besar, diff --git a/id-id/php-id.html.markdown b/id-id/php-id.html.markdown new file mode 100644 index 00000000..34d6e5f5 --- /dev/null +++ b/id-id/php-id.html.markdown @@ -0,0 +1,848 @@ +--- +language: PHP +contributors: + - ["Malcolm Fell", "http://emarref.net/"] + - ["Trismegiste", "https://github.com/Trismegiste"] +filename: learnphp-id.php +translators: + - ["Ahmad Zafrullah", "https://github.com/23Pstars"] +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" or "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 simnbol $. +// Nama variabel yang benar diawali dengan huruf atau garis-bawah, +// diikuti dengan beberapa huruf, angka, dan garis-bawah lainnya. + +// 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 ditampilkan) +echo ++$angka; // Menampilkan 3 (dijumlahkan dengan 1 sebelum ditampilkan) +$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 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; + +// Menyambung string dapat dilakukan menggunakan . +echo 'String ini ' . 'tersambung'; + +// String dapat dijadikan parameter pada "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, atau 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'; + +// menegaskan lemparan 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 $variabel = 'terlindungi'; // Dapat diakses dari kelas itu sendiri dan kelas turunannya + private $variabel = '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() + { + } + +/* + * 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" + +// Menurunkan kelas menggunakan kata kunci "extends" +class KelasSayaLainnya extends KelasSaya +{ + function tampilkanPropertiTerlindungi() + { + echo $this->properti; + } + + // "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::who(); + // kata kunci "static" merujuk pada method yang berada di kelas dimana method itu dijalankan + static::who(); + } +} + +KelasInduk::coba(); +/* +Ini adalah KelasInduk +Ini adalah KelasInduk +*/ + +class KelasAnak extends KelasInduk { + public static function siapa() { + echo "Tapi ini adalah " . __CLASS__ . "\n"; + } +} + +KelasAnak::tes(); +/* +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). diff --git a/id-id/ruby-id.html.markdown b/id-id/ruby-id.html.markdown new file mode 100644 index 00000000..28135da1 --- /dev/null +++ b/id-id/ruby-id.html.markdown @@ -0,0 +1,622 @@ +--- +language: ruby +filename: learnruby-id.rb +contributors: + - ["David Underwood", "http://theflyingdeveloper.com"] + - ["Joel Walden", "http://joelwalden.net"] + - ["Luke Holder", "http://twitter.com/lukeholder"] + - ["Tristan Hume", "http://thume.ca/"] + - ["Nick LaMuro", "https://github.com/NickLaMuro"] + - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"] + - ["Ariel Krakowski", "http://www.learneroo.com"] + - ["Dzianis Dashkevich", "https://github.com/dskecse"] + - ["Levi Bostian", "https://github.com/levibostian"] + - ["Rahil Momin", "https://github.com/iamrahil"] + - ["Gabriel Halley", "https://github.com/ghalley"] + - ["Persa Zula", "http://persazula.com"] + - ["Jake Faris", "https://github.com/farisj"] +translators: + - ["Ukaza Perdana", "https://github.com/ukazap"] +lang: id-id +--- + +```ruby +# Ini adalah sebuah komentar + +=begin +Ini adalah komentar multibaris +Tak seorang pun menggunakannya +Kamu juga tidak perlu +=end + +# Pertama-tama dan yang terpenting: Semuanya adalah objek. + +# Angka adalah objek + +3.class #=> Fixnum + +3.to_s #=> "3" + + +# Beberapa aritmetika dasar +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 +2**5 #=> 32 +5 % 3 #=> 2 + +# Operator-operator bitwise +3 & 5 #=> 1 +3 | 5 #=> 7 +3 ^ 5 #=> 6 + +# Aritmetika tidak lain adalah pemanis sintaks (syntactic sugar) +# untuk memanggil sebuah metode pada suatu objek +1.+(3) #=> 4 +10.* 5 #=> 50 + +# Nilai-nilai khusus adalah objek +nil # setara dengan "null" di bahasa-bahasa lain +true # kebenaran +false # ketidakbenaran + +nil.class #=> NilClass +true.class #=> TrueClass +false.class #=> FalseClass + +# Kesamaan +1 == 1 #=> true +2 == 1 #=> false + +# Ketidaksamaan +1 != 1 #=> false +2 != 1 #=> true + +# selain false itu sendiri, nil adalah nilai lain yang "salah" +!nil #=> true +!false #=> true +!0 #=> false + +# Perbandingan lain +1 < 10 #=> true +1 > 10 #=> false +2 <= 2 #=> true +2 >= 2 #=> true + +# Operator pembanding yang dikombinasikan ("spaceship operator") +1 <=> 10 #=> -1 +10 <=> 1 #=> 1 +1 <=> 1 #=> 0 + +# Operator-operator logika +true && false #=> false +true || false #=> true +!true #=> false + +# Terdapat versi-versi operator logika yang berbeda dengan lebih sedikit awalan. +# Mereka digunakan sebagai kendali alur untuk merangkai beberapa pernyataan +# hingga salah satunya mengembalikan (return) nilai true atau false. + +# `lakukan_suatu_lainnya` hanya dipanggil jika `lakukan_sesuatu` berhasil. +lakukan_sesuatu() and lakukan_suatu_lainnya() +# `catat_error` hanya dipanggil jika `lakukan_sesuatu` gagal. +lakukan_sesuatu() or catat_error() + + +# String adalah objek + +'Aku adalah string'.class #=> String +"Aku juga adalah string".class #=> String + +wadah = 'menggunakan string interpolation' +"Aku bisa #{wadah} ketika memakai tanda kutip ganda" +#=> "Aku bisa menggunakan string interpolation ketika memakai tanda kutip ganda" + +# Gunakan tanda kutip tunggal daripada tanda kutip ganda jika memungkinkan +# String bertanda kutip ganda melakukan kalkulasi tambahan di dalam + +# Kombinasikan string, tapi tidak dengan angka +'halo ' + 'dunia' #=> "halo dunia" +'halo ' + 3 #=> TypeError: can't convert Fixnum into String +'halo ' + 3.to_s #=> "halo 3" + +# Kombinasikan string dengan operator +'halo ' * 3 #=> "halo halo halo " + +# Membubuhkan ke string +'halo' << ' dunia' #=> "halo dunia" + +# cetak ke output dan buat baris baru (newline) di akhir +puts "Aku mencetak!" +#=> Aku mencetak! +#=> nil + +# cetak ke output tanpa baris baru +print "Aku mencetak!" +#=> Aku mencetak! => nil + +# Variabel +x = 25 #=> 25 +x #=> 25 + +# Catat bahwa pemberian nilai mengembalikan nilai yang diberikan +# Artinya kamu bisa melakukan pemberian nilai secara jamak: + +x = y = 10 #=> 10 +x #=> 10 +y #=> 10 + +# Berdasarkan adat, gunakan gaya snake_case untuk menulis nama variabel +snake_case = true + +# Gunakan nama variabel yang deskriptif +path_to_project_root = '/good/name/' +path = '/bad/name/' + +# Simbol (adalah objek) +# Simbol adalah konstanta yang dapat didaur ulang yang tidak dapat diubah +# (immutable), secara internal diwakili oleh nilai integer. Seringkali +# digunakan sebagai pengganti string untuk menyampaikan nilai yang mengandung +# makna spesifik secara efisien. + +:menunggu.class #=> Symbol + +status = :menunggu + +status == :menunggu #=> true + +status == 'menunggu' #=> false + +status == :diterima #=> false + +# Array + +# Ini adalah sebuah array +array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] + +# Array bisa menampung item dengan beragam tipe + +[1, 'halo', false] #=> [1, "halo", false] + +# Array bisa di-indeks-kan +# Dari depan +array[0] #=> 1 +array.first #=> 1 +array[12] #=> nil + +# Sama dengan aritmetika, pengaksesan [var] +# hanyalah pemanis sintaks +# untuk memanggil metode [] pada suatu objek +array.[] 0 #=> 1 +array.[] 12 #=> nil + +# Dari belakang +array[-1] #=> 5 +array.last #=> 5 + +# Dengan indeks awal dan panjang (jumlah item) +array[2, 3] #=> [3, 4, 5] + +# Membalik sebuah Array +a=[1,2,3] +a.reverse! #=> [3,2,1] + +# Atau menggunakan jangkauan (range) +array[1..3] #=> [2, 3, 4] + +# Tambahkan ke array seperti ini +array << 6 #=> [1, 2, 3, 4, 5, 6] +# Atau seperti ini +array.push(6) #=> [1, 2, 3, 4, 5, 6] + +# Periksa apakah suatu item ada dalam sebuah array +array.include?(1) #=> true + +# Hash adalah kamus utama Ruby berupa pasangan kunci/nilai (key/value pair). +# Hash ditandai dengan kurung kurawal: +hash = { 'warna' => 'hijau', 'angka' => 5 } + +hash.keys #=> ['warna', 'angka'] + +# Nilai dalam Hash bisa diperoleh menggunakan kunci: +hash['warna'] #=> 'hijau' +hash['angka'] #=> 5 + +# Meminta hash untuk kunci yang tidak ada akan mengembalikan nil: +hash['tidak ada di sini'] #=> nil + +# Sejak Ruby 1.9, ada sintaks khusus ketika menggunakan simbol sebagai kunci: + +hash_baru = { defcon: 3, action: true } + +hash_baru.keys #=> [:defcon, :action] + +# Periksa ada/atau tidaknya kunci dan nilai dalam hash +hash_baru.key?(:defcon) #=> true +hash_baru.value?(3) #=> true + +# Tip: Baik array maupun hash adalah Enumerable +# Mereka berbagi banyak metode yang berguna diantaranya each, map, count, dll. + +# Struktur-struktur kendali + +if true + 'pernyataan if' +elsif false + 'else if, opsional' +else + 'else, opsional juga' +end + +for penghitung in 1..5 + puts "iterasi #{penghitung}" +end +#=> iterasi 1 +#=> iterasi 2 +#=> iterasi 3 +#=> iterasi 4 +#=> iterasi 5 + +# NAMUN, tidak ada orang yang menggunakan pengulangan for. +# Sebagai ganti, gunakan metode "each" dan memberinya sebuah blok (block). +# Blok adalah serangkaian kode yang bisa dimasukkan ke metode seperti "each". +# Ia serupa dengan lambda, fungsi anonim atau closure di bahasa lainnya. +# +# Metode "each" dari range menjalankan blok untuk setiap elemen dari range. +# Bloknya diberikan penghitung sebagai parameter. +# Memanggil metode "each" dengan blok terlihat seperti ini: + +(1..5).each do |penghitung| + puts "iterasi #{penghitung}" +end +#=> iterasi 1 +#=> iterasi 2 +#=> iterasi 3 +#=> iterasi 4 +#=> iterasi 5 + +# Kamu juga bisa mengurung blok dalam kurung kurawal: +(1..5).each { |penghitung| puts "iterasi #{penghitung}" } + +# Isi dari struktur-struktur data juga bisa di-iterasi menggunakan each. +array.each do |elemen| + puts "#{elemen} adalah bagian dari array" +end +hash.each do |kunci, nilai| + puts "#{kunci} adalah #{nilai}" +end + +# Jika kamu masih membutuhkan indeks, bisa menggunakan "each_with_index" +# dan definisikan variabel indeks +array.each_with_index do |elemen, indeks| + puts "#{elemen} adalah nomor #{indeks} dalam array" +end + +penghitung = 1 +while penghitung <= 5 do + puts "iterasi #{penghitung}" + penghitung += 1 +end +#=> iterasi 1 +#=> iterasi 2 +#=> iterasi 3 +#=> iterasi 4 +#=> iterasi 5 + +# Ada kumpulan fungsi pengulangan lainnya yang berguna di Ruby, +# contohnya "map", "reduce", "inject", daftarnya sangat panjang. Map, +# misalnya, mengambil array yang di-iterasi-nya, melakukan sesuatu pada +# setiap elemen sesuai definisi pada blok, dan mengembalikan array baru. +array = [1,2,3,4,5] +berganda = array.map do |elemen| + elemen * 2 +end +puts berganda +#=> [2,4,6,8,10] +puts array +#=> [1,2,3,4,5] + +nilai = 'B' + +case nilai +when 'A' + puts 'Pertahankan, nak' +when 'B' + puts 'Semoga lebih beruntung di lain waktu' +when 'C' + puts 'Kamu bisa lebih baik' +when 'D' + puts 'Susah payah' +when 'F' + puts 'Kamu gagal!' +else + puts 'Sistem penilaian lainnya, heh?' +end +#=> "Semoga lebih beruntung di lain waktu" + +# case juga bisa menggunakan range +nilai = 82 +case nilai +when 90..100 + puts 'Hore!' +when 80...90 + puts 'Cukup bagus' +else + puts 'Kamu gagal!' +end +#=> "Cukup bagus" + +# penanganan kesalahan (exception handling): +begin + # kode di sini yang mungkin membangkitkan exception + raise NoMemoryError, 'Kamu kehabisan memori.' +rescue NoMemoryError => variabel_exception + puts 'NoMemoryError dibangkitkan', variabel_exception +rescue RuntimeError => variabel_exception_lainnya + puts 'RuntimeError dibangkitkan sekarang' +else + puts 'Ini dijalankan bila tidak ada exceptions sama sekali' +ensure + puts 'Kode ini akan berjalan bagaimanapun juga' +end + +# Fungsi (atau metode) + +def gandakan(x) + x * 2 +end + +# Fungsi dan semua blok secara tersirat mengembalikan nilai pernyataan terakhir +gandakan(2) #=> 4 + +# Tanda kurung bersifat optional, boleh ditiadakan jika tidak ambigu +gandakan 3 #=> 6 + +gandakan gandakan 3 #=> 12 + +def jumlah(x, y) + x + y +end + +# Argumen-argumen dari metode dipisahkan dengan koma +sum 3, 4 #=> 7 + +sum sum(3, 4), 5 #=> 12 + +# yield +# Semua metode secara tersirat mempunyai parameter blok opsional +# yang bisa dipanggil dengan kata kunci 'yield' + +def kurung + puts '{' + yield + puts '}' +end + +kurung { puts 'halo dunia' } + +# { +# halo dunia +# } + + +# Kamu bisa memasukkan blok ke sebuah fungsi +# "&" adalah penanda blok yang masuk +def tamu_tamu(&blok) + blok.call 'beberapa_argumen' +end + +# Kamu bisa memasukkan daftar argumen yang akan dikonversi menjadi array +# Itulah gunanya operator splat ("*") +def tamu_tamu(*array) + array.each { |tamu| puts tamu } +end + +# Bila metode mengembalikan array, bisa memberi nilai dengan destrukturisasi +# (destructuring assignment): +def makanan + ['tempe penyet', 'sayur asam', 'nasi goreng'] +end +sarapan, makan_siang, makan_malam = makanan +sarapan #=> 'tempe penyet' +makan_malam #=> 'nasi goreng' + +# Menurut adat, nama metode yang mengembalikan boolean diakhiri tanda tanya +5.even? # false +5.odd? # true + +# Dan jika suatu metode berakhiran tanda seru, ia melakukan sesuatu yang merusak +# seperti mengubah penerimanya. Banyak metode mempunyai versi ! untuk melakukan +# perubahan dan versi non-! untuk sekedar mengembalikan perubahannya +nama_perusahaan = "Putra Sejahtera" +nama_perusahaan.upcase #=> "PUTRA SEJAHTERA" +nama_perusahaan #=> "Putra Sejahtera" +nama_perusahaan.upcase! # kali ini kita benar-benar mengubah nama_perusahaan! +nama_perusahaan #=> "PUTRA SEJAHTERA" + + +# Definisikan kelas menggunakan kata kunci class +class Manusia + + # Variabel kelas. Ini dibagi oleh semua instans (instance) dari kelas ini. + @@spesies = 'H. sapiens' + + # Inisialisasi dasar + def initialize(nama, usia = 0) + # Berikan argumen ke variabel instans "nama" dalam instans ini + @nama = nama + # Jika tidak diberi usia, nilai default dalam daftar argumen digunakan. + @usia = usia + end + + # Metode setter dasar + def nama=(nama) + @nama = nama + end + + # Metode getter dasar + def nama + @nama + end + + # Fungsi di atas bisa disingkat dengan metode attr_accessor sebagai berikut + attr_accessor :nama + + # Metode getter/setter juga bisa dibuat secara terpisah seperti ini + attr_reader :nama + attr_writer :nama + + # Metode kelas menggunakan self untuk membedakannya dari metode instans. + # Ia hanya bisa dipanggil pada kelas, bukan pada instans-nya. + def self.katakan(pesan) + puts pesan + end + + def spesies + @@spesies + end +end + + +# Membuat instans kelas +jim = Manusia.new('Jim Halpert') + +dwight = Manusia.new('Dwight K. Schrute') + +# Mari panggil beberapa metode +jim.spesies #=> "H. sapiens" +jim.nama #=> "Jim Halpert" +jim.nama = "Jim Halpert II" #=> "Jim Halpert II" +jim.nama #=> "Jim Halpert II" +dwight.spesies #=> "H. sapiens" +dwight.nama #=> "Dwight K. Schrute" + +# Panggil metode kelas +Manusia.katakan('Hai') #=> "Hai" + +# Lingkup variabel didefinisikan berdasarkan bagaimana kita memberikannya nama +# Variabel yang berawalan $ memiliki lingkup global +$var = "Aku adalah variabel global" +defined? $var #=> "global-variable" + +# Variabel yang berawalan @ memiliki lingkup instans +@var = "Aku adalah variabel instans" +defined? @var #=> "instance-variable" + +# Variabel yang berawalan @@ memiliki lingkup kelas +@@var = "Aku adalah variabel kelas" +defined? @@var #=> "class variable" + +# Variabel yang berawalan huruf kapital adalah konstanta +Var = "Aku adalah konstanta" +defined? Var #=> "constant" + +# Kelas juga adalah objek sehingga kelas bisa memiliki variabel instans. +# Variabel kelas dibagi diantara kelas dan semua pewarisnya. + +# kelas dasar +class Manusia + @@foo = 0 + + def self.foo + @@foo + end + + def self.foo=(nilai) + @@foo = nilai + end +end + +# kelas turunan +class Buruh < Manusia +end + +Manusia.foo # 0 +Buruh.foo # 0 + +Manusia.foo = 2 # 2 +Buruh.foo # 2 + +# Variabel instans milik kelas tidak dibagikan dengan pewaris kelas tersebut. + +class Manusia + @bar = 0 + + def self.bar + @bar + end + + def self.bar=(nilai) + @bar = nilai + end +end + +class Dokter < Manusia +end + +Manusia.bar # 0 +Dokter.bar # nil + +module ContohModul + def foo + 'foo' + end +end + +# Include modul mengikat metode-metodenya pada instans-instans kelas +# Extend modul mengikat metode-metodenya pada kelas + +class Orang + include ContohModul +end + +class Buku + extend ContohModul +end + +Orang.foo # => NoMethodError: undefined method `foo' for Orang:Class +Orang.new.foo # => 'foo' +Buku.foo # => 'foo' +Buku.new.foo # => NoMethodError: undefined method `foo' + +# Callbacks dijalankan ketika meng-include dan meng-extend sebuah modul + +module ContohUrusan + def self.included(base) + base.extend(MetodeKelas) + base.send(:include, MetodeInstans) + end + + module MetodeKelas + def bar + 'bar' + end + end + + module MetodeInstans + def qux + 'qux' + end + end +end + +class Sesuatu + include ContohUrusan +end + +Sesuatu.bar # => 'bar' +Sesuatu.qux # => NoMethodError: undefined method `qux' +Sesuatu.new.bar # => NoMethodError: undefined method `bar' +Sesuatu.new.qux # => 'qux' +``` + +## Sumber tambahan + +- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - Varian dari referensi ini dengan tantangan dalam browser. +- [An Interactive Tutorial for Ruby](https://rubymonk.com/) - Belajar Ruby melalui serangkaian tutorial interaktif. +- [Dokumentasi resmi](http://www.ruby-doc.org/core-2.1.1/) +- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/) +- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Edisi lama yang [gratis](http://ruby-doc.com/docs/ProgrammingRuby/) tersedia online. +- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - Panduan penulisan kode Ruby oleh komunitas. +- [Try Ruby](http://tryruby.org) - Pelajari dasar bahasa pemrograman Ruby, secara interaktif di browser. diff --git a/id-id/xml-id.html.markdown b/id-id/xml-id.html.markdown index 8b8d72ae..fedba711 100644 --- a/id-id/xml-id.html.markdown +++ b/id-id/xml-id.html.markdown @@ -5,19 +5,76 @@ contributors: - ["João Farias", "https://github.com/JoaoGFarias"] translators: - ["Rizky Luthfianto", "https://github.com/rilut"] + - ["Ahmad Zafrullah", "https://github.com/23Pstars"] lang: id-id --- -XML adalah bahasa markup yang dirancang untuk menyimpan dan mengirim data. +XML adalah bahasa markup yang dirancang untuk menyimpan dan mengirim data. XML mudah dibaca oleh manusia dan mesin. Tidak seperti HTML, XML tidak menentukan bagaimana menampilkan atau format data, hanya membawanya. -* Sintaks XML +Terdapat perbedaan antara **konten** dan **markup**. Singkatnya, konten dapat berupa apapun dan markup adalah sebagai penentu. + +## Definisi dan Pendahuluan + +Dokumen XML pada dasarnya disusun oleh *elemen* yang dapat memiliki *atribut* untuk menjelaskan elemen tersebut dan dapat memiliki beberapa konten tekstual atau beberapa elemen sebagai anak-nya. Setiap dokumen XML hendaknya memiliki satu elemen akar, yang menjadi induk dari semua elemen dalam dokumen XML. + +Pengurai XML dirancang menjadi sangat ketat, dan akan berhenti melakukan penguraian terhadap dokumen yang cacat. Oleh karena itu semua dokumen XML harus mengikuti [Aturan Sintaks XML](http://www.w3schools.com/xml/xml_syntax.asp). ```xml -<!-- Komentar di XML seperti ini --> +<!-- Ini adalah komentar. Komentar harus memiliki dua tanda penghubung secara berurutan (-). --> +<!-- Komentar dapat renggang + menjadi banyak baris --> + +<!-- Elemen --> +<!-- Elemen merupakan komponen dasar dari XML. Ada dua tipe dari elemen, kosong: --> +<elemen1 atribut="nilai" /> <!-- Elemen kosong tidak memiliki konten apapun --> +<!-- dan tidak-kosong: --> +<elemen2 atribut="nilai">Konten</elemen2> +<!-- Nama elemen hanya dapat berupa huruf dan angka saja. --> + +<kosong /> <!-- Elemen yang terdiri dari tag elemen kosong… --> +<!-- …tidak memiliki content apapun dan murni markup. --> + +<tidakkosong> <!-- Atau, elemen ini memiliki tag pembuka… --> + <!-- …suatu konten… --> +</tidakkosong> <!-- dan sebuah tag penutup. --> + +<!-- Nama elemen merupakan *case sensitive*. --> +<elemen /> +<!-- …tidak sama dengan elemen sebelumnya --> +<eLEMEN /> + +<!-- Atribut --> +<!-- Sebuah atribut merupakan hubungan kunci-nilai yang terdapat pada elemen. --> +<elemen atribut="nilai" lainnya="nilaiLainnya" banyakNilai="daftar nilai ber-spasi" /> +<!-- Sebuah atribut digunakan hanya sekali dalam sebuah elemen. Dan hanya memiliki satu nilai. + Salah satu solusi untuk mengatasi permasalahan tersebut adalah dengan menggunakan daftar nilai ber-spasi. --> + +<!-- Elemen bersarang --> +<!-- Konten dari sebuah elemen dapat berupa elemen lainnya:: --> +<ayah> + <anak>Teks</anak> + <oranglain /> +</ayah> +<!-- Mengikuti standar tatanan pohon. Setiap elemen disebut *node*. + Induk yang berada satu tingkat diatasnya disebut *parent*, keturunan yang berada satu tingkat dibawahnya disebut *children*. + Elemen yang berada pada *parent* yang sama disebut Saudara (*siblings*). --> + +<!-- XML mempertahankan spasi. --> +<anak> + Teks +</anak> +<!-- …tidak sama dengan --> +<anak>Teks</anak> +``` + + +## Dokumen XML +```xml <?xml version="1.0" encoding="UTF-8"?> +<!-- XML prolog, boleh tidak digunakan namun direkomendasikan untuk digunakan. --> <tokobuku> <buku category="MEMASAK"> <judul lang="en">Everyday Italian</judul> @@ -65,7 +122,7 @@ Tidak seperti HTML, XML tidak menentukan bagaimana menampilkan atau format data, ``` -* Dokumen yang well-formated & Validasi +## Dokumen yang well-formated & Validasi Sebuah dokumen XML disebut well-formated jika sintaksisnya benar. Namun, juga mungkin untuk mendefinisikan lebih banyak batasan dalam dokumen, @@ -128,3 +185,17 @@ Dengan alat ini, Anda dapat memeriksa data XML di luar logika aplikasi. </buku> </tokobuku> ``` +## Kompatibilitas DTD dan Definisi Skema XML + +Dukungan untuk DTD dapat ditemukan dimana-mana karena sudah sangat lama. Namun sayangnya, fitur XML terkini seperti *namespaces* tidak didukung oleh DTD. XML Xchema Definitions (XSDs) bertujuan untuk mengganti DTD dalam mendefinisikan tatabahasa dokumen XML. + +## Sumber + +* [Validasi dokumen XML](http://www.xmlvalidation.com) + +## Bacaan lainnya + +* [XML Schema Definitions Tutorial](http://www.w3schools.com/schema/) +* [DTD Tutorial](http://www.w3schools.com/xml/xml_dtd_intro.asp) +* [XML Tutorial](http://www.w3schools.com/xml/default.asp) +* [Using XPath queries to parse XML](http://www.w3schools.com/xml/xml_xpath.asp) |