Tipe Data #

<?php
// Notasi desimal (basis 10) — yang paling umum
$positif  = 42;
$negatif  = -273;
$nol      = 0;

// Notasi heksadesimal (basis 16) — diawali 0x
$hex      = 0x1A;       // 26 dalam desimal
$hexBesar = 0xFF;       // 255

// Notasi oktal (basis 8) — diawali 0
$oktal    = 0755;       // 493 — familiar dari chmod di Linux

// Notasi biner (basis 2) — diawali 0b
$biner    = 0b11111111; // 255

// Underscore sebagai pemisah ribuan (PHP 7.4+) — hanya kosmetik
$jutaan   = 1_000_000;
$byte     = 0xFF_FF_FF_FF;

var_dump($positif); // int(42)
var_dump($hex);     // int(26)
var_dump($jutaan);  // int(1000000)

<?php
echo PHP_INT_MAX;  // 9223372036854775807 (64-bit)
echo PHP_INT_MIN;  // -9223372036854775808
echo PHP_INT_SIZE; // 8 (byte)

// Integer overflow — otomatis jadi float, bukan error
$batas = PHP_INT_MAX;
var_dump($batas);       // int(9223372036854775807)
var_dump($batas + 1);   // float(9.2233720368548E+18) — bukan integer lagi!

// Untuk aritmatika presisi tinggi (uang, kriptografi), gunakan BCMath
$hasil = bcadd('9223372036854775807', '1');
echo $hasil; // 9223372036854775808 — benar sebagai string

<?php
// Konversi basis
echo decbin(255);    // "11111111"   — desimal ke biner
echo decoct(255);    // "377"        — desimal ke oktal
echo dechex(255);    // "ff"         — desimal ke heksadesimal
echo bindec('1010'); // 10           — biner ke desimal

// Operasi matematika integer
echo abs(-42);          // 42  — nilai absolut
echo intdiv(17, 5);     // 3   — pembagian integer (PHP 7+)
echo fmod(17, 5);       // 2   — modulo float
echo pow(2, 10);        // 1024

// Cek apakah nilai adalah integer
var_dump(is_int(42));     // true
var_dump(is_int(42.0));   // false
var_dump(is_int('42'));   // false
var_dump(is_numeric('42')); // true — termasuk string numerik

<?php
$pi       = 3.14159265358979;
$negatif  = -2.718;
$ilmiah   = 1.5e3;    // 1500.0 — notasi ilmiah
$kecil    = 2.5e-4;   // 0.00025

echo PHP_FLOAT_MAX;      // 1.7976931348623E+308
echo PHP_FLOAT_MIN;      // 2.2250738585072E-308 (nilai positif terkecil)
echo PHP_FLOAT_EPSILON;  // 2.2204460492503E-16 (akurasi float)

var_dump($pi);      // float(3.14159265358979)
var_dump($ilmiah);  // float(1500)

<?php
// ANTI-PATTERN: membandingkan float dengan ==
$a = 0.1 + 0.2;
var_dump($a == 0.3);          // bool(false) — MENGEJUTKAN!
var_dump($a);                 // float(0.30000000000000004)

// Kenapa? Karena 0.1 dan 0.2 tidak bisa direpresentasikan secara persis
// dalam binary floating point — mirip seperti 1/3 tidak bisa persis dalam desimal.

// BENAR: gunakan epsilon untuk perbandingan float
function floatEquals(float $a, float $b, float $epsilon = PHP_FLOAT_EPSILON): bool
{
    return abs($a - $b) < $epsilon;
}

var_dump(floatEquals(0.1 + 0.2, 0.3)); // bool(true)

// Atau gunakan round() sebelum membandingkan
var_dump(round(0.1 + 0.2, 10) === round(0.3, 10)); // bool(true)

<?php
// ANTI-PATTERN: kalkulasi uang dengan float
$harga  = 19.99;
$qty    = 3;
$total  = $harga * $qty;
echo $total; // 59.97 — kebetulan benar, tapi tidak selalu

$potongan = 0.1; // 10%
echo $total - ($total * $potongan); // 53.973 — mungkin presisi tidak pas

// BENAR: simpan dalam satuan terkecil (misalnya sen)
$hargaSen = 1999;   // Rp 19,99 disimpan sebagai 1999 sen
$qtySen   = 3;
$totalSen = $hargaSen * $qtySen; // 5997 sen = Rp 59,97
echo $totalSen / 100;             // tampilkan: 59.97

// Atau pakai BCMath untuk presisi penuh
$hargaBc = '19.99';
$totalBc = bcmul($hargaBc, '3', 2); // '59.97' — presisi 2 desimal

<?php
// Infinity dan NaN
$inf     = INF;
$negInf  = -INF;
$nan     = NAN;

var_dump(is_infinite(INF));      // true
var_dump(is_infinite(1.0));      // false
var_dump(is_nan(NAN));           // true
var_dump(is_nan(sqrt(-1)));      // true — akar negatif menghasilkan NaN
var_dump(is_finite(42.0));       // true
var_dump(is_finite(INF));        // false

// Operasi yang menghasilkan INF
var_dump(log(0));    // float(-INF)
var_dump(1 / 0.0);   // float(INF) — bukan error!

<?php
// Kutip satu — tidak ada interpolasi, tidak ada escape sequence (kecuali \\ dan \')
$s1 = 'Halo, $nama!';         // teks literal, $ tidak diinterpolasi
$s2 = 'Baris pertama\nKedua'; // \n tidak jadi newline

// Kutip dua — interpolasi variabel dan escape sequence aktif
$nama = "Budi";
$s3 = "Halo, $nama!";         // Halo, Budi!
$s4 = "Baris pertama\nKedua"; // \n jadi newline

// Escape sequence yang berlaku di kutip dua:
// \n  — newline         \t  — tab
// \r  — carriage return \$  — tanda dollar literal
// \\  — backslash       \"  — kutip dua literal
// \0  — null byte       \u{1F600} — Unicode codepoint (PHP 7+)

echo "\u{1F600}"; // 😀

<?php
$teks = "  Halo, Dunia PHP!  ";

// Panjang string — dalam BYTE, bukan karakter
echo strlen($teks);         // 22

// Panjang dalam karakter multibyte (UTF-8)
echo mb_strlen($teks);      // 22 (sama jika semua ASCII)
echo mb_strlen("日本語");    // 3  — tiga karakter
echo strlen("日本語");       // 9  — sembilan byte (UTF-8: 3 byte per kanji)

// Trim — hapus whitespace
echo trim($teks);           // "Halo, Dunia PHP!"
echo ltrim($teks);          // "Halo, Dunia PHP!  " (kiri saja)
echo rtrim($teks);          // "  Halo, Dunia PHP!" (kanan saja)

// Transformasi case
echo strtolower("HALO");    // "halo"
echo strtoupper("halo");    // "HALO"
echo ucfirst("halo dunia"); // "Halo dunia"
echo ucwords("halo dunia"); // "Halo Dunia"

// Untuk teks multibyte (non-ASCII), gunakan mb_ prefix
echo mb_strtolower("HÉLLO"); // "héllo" — benar
echo strtolower("HÉLLO");    // mungkin salah tergantung locale

// Pencarian dan penggantian
echo strpos("Halo PHP", "PHP");    // 5 — posisi pertama ditemukan
echo str_contains("Halo PHP", "PHP");  // true  (PHP 8+)
echo str_starts_with("Halo", "Ha");    // true  (PHP 8+)
echo str_ends_with("Halo", "lo");      // true  (PHP 8+)
echo str_replace("PHP", "World", "Halo PHP"); // "Halo World"

// Pemisahan dan penggabungan
$csv   = "apel,mangga,jeruk";
$buah  = explode(",", $csv);         // ["apel", "mangga", "jeruk"]
$kembali = implode(" | ", $buah);   // "apel | mangga | jeruk"

// Substring
echo substr("Halo PHP", 5);         // "PHP"
echo substr("Halo PHP", 0, 4);      // "Halo"
echo substr("Halo PHP", -3);        // "PHP" (dari belakang)

<?php
$teks = "Halo";

// Akses karakter per karakter seperti array
echo $teks[0];    // H
echo $teks[1];    // a
echo $teks[-1];   // o (dari belakang, PHP 7.1+)

// Iterasi per karakter
for ($i = 0; $i < strlen($teks); $i++) {
    echo $teks[$i] . " "; // H a l o
}

// PERHATIAN: ini akses per byte, bukan per karakter Unicode!
$unicode = "日本";
echo $unicode[0]; // byte pertama dari 日 — bukan karakter utuh!
// Untuk multibyte, gunakan mb_substr()
echo mb_substr($unicode, 0, 1); // "日" — karakter pertama yang benar

<?php
$aktif   = true;
$nonaktif = false;

var_dump($aktif);    // bool(true)
var_dump($nonaktif); // bool(false)

// Boolean dalam konteks kondisional
if ($aktif) {
    echo "Aktif";
}

// Konversi ke string
echo var_export(true, true);  // 'true'
echo var_export(false, true); // 'false'
echo (string) true;           // "1"
echo (string) false;          // "" (string kosong!)

// ini mengejutkan banyak orang:
echo true;   // 1
echo false;  // (tidak ada output — empty string)

<?php
// Semua nilai ini dianggap FALSE:
var_dump((bool) false);    // false — boolean false
var_dump((bool) 0);        // false — integer nol
var_dump((bool) 0.0);      // false — float nol
var_dump((bool) -0.0);     // false — float nol negatif
var_dump((bool) "");       // false — string kosong
var_dump((bool) "0");      // false — string "0" (jebakan umum!)
var_dump((bool) []);       // false — array kosong
var_dump((bool) null);     // false — null

// Semua nilai lain dianggap TRUE, termasuk:
var_dump((bool) -1);       // true  — integer negatif non-nol
var_dump((bool) 0.1);      // true  — float positif apapun
var_dump((bool) "false");  // true! — string non-kosong, meski isinya "false"
var_dump((bool) "0.0");    // true! — string "0.0" bukan "0"
var_dump((bool) [0]);      // true  — array dengan satu elemen
var_dump((bool) new stdClass()); // true — object selalu true

<?php
// Array terindeks (indeks integer dimulai dari 0)
$buah = ["apel", "mangga", "jeruk"];

// Array asosiatif (indeks string)
$profil = [
    "nama"  => "Budi",
    "umur"  => 28,
    "kota"  => "Jakarta",
];

// Array campuran — valid tapi sebaiknya dihindari
$campur = [
    0       => "nol",
    "satu"  => 1,
    2       => "dua",
    "tiga"  => 3,
];

// Array multidimensi
$tabel = [
    ["id" => 1, "nama" => "Laptop",  "harga" => 15000000],
    ["id" => 2, "nama" => "Monitor", "harga" => 5000000],
    ["id" => 3, "nama" => "Keyboard","harga" => 800000],
];

// Akses
echo $buah[0];              // apel
echo $profil["nama"];       // Budi
echo $tabel[1]["nama"];     // Monitor

// Modifikasi
$buah[] = "anggur";         // tambah di akhir
$buah[0] = "apel merah";   // ubah elemen
unset($buah[1]);             // hapus elemen (indeks tidak di-reindex!)

<?php
$angka = [5, 3, 8, 1, 9, 2, 7, 4, 6];

// Informasi
echo count($angka);           // 9
echo array_sum($angka);       // 45
echo min($angka);             // 1
echo max($angka);             // 9

// Transformasi — menghasilkan array baru, tidak ubah asli
$kali2   = array_map(fn($n) => $n * 2, $angka);
$genap   = array_filter($angka, fn($n) => $n % 2 === 0);
$total   = array_reduce($angka, fn($carry, $n) => $carry + $n, 0);

// Sorting — mengubah array asli
$salin = $angka;
sort($salin);                 // ascending: [1,2,3,4,5,6,7,8,9]
rsort($salin);                // descending: [9,8,7,6,5,4,3,2,1]

$profil = ["nama" => "Budi", "kota" => "Bandung", "umur" => 28];
asort($profil);               // sort by value, pertahankan key
ksort($profil);               // sort by key

// Pencarian
echo in_array(8, $angka);             // true
echo array_search(8, $angka);         // 2 (indeks)

// Slicing dan splicing
$potongan = array_slice($angka, 2, 4); // 4 elemen mulai indeks 2
array_splice($angka, 1, 2, [10, 11]); // ganti 2 elemen mulai indeks 1

// Penggabungan
$a = [1, 2, 3];
$b = [4, 5, 6];
$gabung     = array_merge($a, $b);    // [1,2,3,4,5,6]
$gabungSpread = [...$a, ...$b];       // [1,2,3,4,5,6] — spread operator

// Array unique dan flip
$duplikat = [1, 2, 2, 3, 3, 3];
$unik     = array_unique($duplikat);  // [1, 2, 3]
$flip     = array_flip(["a" => 1, "b" => 2]); // [1 => "a", 2 => "b"]

<?php
class Produk
{
    public function __construct(
        private int    $id,
        private string $nama,
        private float  $harga,
        private int    $stok = 0,
    ) {}

    public function getId(): int      { return $this->id; }
    public function getNama(): string { return $this->nama; }
    public function getHarga(): float { return $this->harga; }
    public function getStok(): int    { return $this->stok; }

    public function tersedia(): bool
    {
        return $this->stok > 0;
    }

    public function hargaFormat(): string
    {
        return 'Rp ' . number_format($this->harga, 0, ',', '.');
    }
}

$laptop = new Produk(1, "Laptop ProBook", 15_000_000, 5);

echo $laptop->getNama();     // Laptop ProBook
echo $laptop->hargaFormat(); // Rp 15.000.000
var_dump($laptop->tersedia()); // bool(true)

// Cek tipe object
var_dump($laptop instanceof Produk); // bool(true)
echo get_class($laptop);             // "Produk"

<?php
// Membuat stdClass secara langsung
$config = new stdClass();
$config->host     = 'localhost';
$config->port     = 3306;
$config->database = 'app_db';

echo $config->host; // localhost

// Casting array ke object
$data = ["nama" => "Budi", "umur" => 28];
$obj  = (object) $data;
echo $obj->nama; // Budi
echo $obj->umur; // 28

// Casting object ke array (berguna untuk serialisasi)
$arr = (array) $obj;
echo $arr['nama']; // Budi

// json_decode menghasilkan stdClass secara default
$json = '{"nama":"Budi","kota":"Jakarta"}';
$user = json_decode($json);          // stdClass
echo $user->nama;                     // Budi

$userArr = json_decode($json, true); // array asosiatif
echo $userArr['nama'];               // Budi

<?php
$belumAda  = null;           // eksplisit null
$juga      = NULL;           // case-insensitive, tapi hindari huruf kapital
$otomatis;                   // variabel yang belum di-assign juga null (tapi akan warning)

var_dump($belumAda);         // NULL
var_dump(is_null($belumAda)); // bool(true)
var_dump(isset($belumAda));  // bool(false)

// Null coalescing — cara idiomatik menangani null
$nama  = null;
$hasil = $nama ?? "Tamu";  // "Tamu" — karena $nama null

// Nullable type — type hint yang menerima null atau tipe tertentu
function cariUser(?int $id): ?array // ? artinya bisa null
{
    if ($id === null) return null;
    // ... cari user
    return ["id" => $id, "nama" => "Budi"];
}

$user = cariUser(null); // valid, mengembalikan null
$user = cariUser(1);    // valid, mengembalikan array

// Nullsafe operator (PHP 8.0+) — rantai method tanpa cek null manual
class User
{
    public ?Address $address = null;
}
class Address
{
    public ?City $city = null;
}
class City
{
    public string $name = "Jakarta";
}

$user = new User();

// ANTI-PATTERN: cek null berulang
$kotaName = null;
if ($user !== null && $user->address !== null && $user->address->city !== null) {
    $kotaName = $user->address->city->name;
}

// BENAR: nullsafe operator (?->)
$kotaName = $user?->address?->city?->name; // null jika ada yang null di rantai

<?php
// Resource file
$file = fopen("data.txt", "r");
if ($file === false) {
    throw new \RuntimeException("Gagal membuka file");
}

var_dump(get_resource_type($file)); // string(6) "stream"
var_dump(is_resource($file));       // bool(true)

while (!feof($file)) {
    $baris = fgets($file);
    echo $baris;
}
fclose($file); // tutup resource — bebaskan memory dan file handle

var_dump(is_resource($file)); // bool(false) — sudah ditutup

// Resource koneksi database (MySQLi)
$db = mysqli_connect('localhost', 'root', '', 'mydb');
var_dump(get_resource_type($db)); // string(5) "mysql link" (PHP < 8)
// Di PHP 8, mysqli mengembalikan object, bukan resource

// Resource cURL
$ch = curl_init('https://api.example.com/data');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

<?php
// Fungsi yang menerima int atau string sebagai ID
function cariProduk(int|string $id): array|null
{
    if (is_int($id)) {
        // cari berdasarkan ID numerik
    } else {
        // cari berdasarkan SKU string
    }
    return null;
}

cariProduk(42);      // ✓ integer
cariProduk("SKU-A"); // ✓ string
// cariProduk(3.14); // ✗ TypeError — float bukan int|string

<?php
interface Stringable
{
    public function __toString(): string;
}

interface Countable
{
    public function count(): int;
}

// Parameter harus implement KEDUANYA — Stringable DAN Countable
function proses(Stringable&Countable $koleksi): void
{
    echo "Jumlah: " . $koleksi->count();
    echo "String: " . $koleksi;
}

<?php
// mixed — menerima tipe apa saja (termasuk null)
function debugDump(mixed $nilai): void
{
    var_dump($nilai);
}

// void — fungsi tidak mengembalikan nilai apapun
function kirimLog(string $pesan): void
{
    file_put_contents('/tmp/app.log', $pesan, FILE_APPEND);
    // return; boleh, tapi return $nilai; adalah error
}

// never — fungsi tidak pernah kembali normal
// (selalu throw exception atau exit)
function gagal(string $pesan): never
{
    throw new \RuntimeException($pesan);
    // atau: exit(1);
}

// Berguna sebagai return type untuk error handler
function tidakDitemukan(): never
{
    http_response_code(404);
    echo json_encode(["error" => "Not found"]);
    exit;
}

<?php
// Tanpa strict_types — PHP melakukan coercion (konversi implisit)
function tambah(int $a, int $b): int
{
    return $a + $b;
}

echo tambah(1, 2);      // 3 — OK
echo tambah("3", "4");  // 7 — PHP konversi string ke int secara diam-diam
echo tambah(1.9, 2.1);  // 3 — PHP truncate float ke int!

// ---

declare(strict_types=1); // aktifkan di baris pertama file

function tambahKetat(int $a, int $b): int
{
    return $a + $b;
}

echo tambahKetat(1, 2);      // 3 — OK
// echo tambahKetat("3", "4"); // TypeError — string bukan int
// echo tambahKetat(1.9, 2.1); // TypeError — float bukan int