Konstanta #

<?php
// ANTI-PATTERN: magic number dan magic string
function prosesOrder(array $order): void
{
    if ($order['status'] === 3) {          // 3 itu apa?
        kirimEmail($order['email'], 5);    // 5 itu apa?
    }

    if (count($order['items']) > 50) {     // kenapa 50?
        throw new Exception("Terlalu banyak item");
    }
}

// BENAR: konstanta yang berbicara sendiri
const STATUS_SELESAI        = 3;
const TEMPLATE_KONFIRMASI   = 5;
const MAX_ITEM_PER_ORDER    = 50;

function prosesOrderV2(array $order): void
{
    if ($order['status'] === STATUS_SELESAI) {
        kirimEmail($order['email'], TEMPLATE_KONFIRMASI);
    }

    if (count($order['items']) > MAX_ITEM_PER_ORDER) {
        throw new Exception("Terlalu banyak item");
    }
}

<?php
// Sintaks dasar
define('NAMA_KONSTANTA', nilai);

// Contoh nyata
define('SITE_NAME',       'Portal Berita Nusantara');
define('SITE_URL',        'https://berita.example.com');
define('MAX_UPLOAD_SIZE', 10 * 1024 * 1024); // 10 MB dalam byte
define('ENABLE_DEBUG',    true);
define('DB_PREFIX',       'app_');

<?php
// Tentukan environment
$env = getenv('APP_ENV') ?: 'production';

// Define konstanta yang berbeda per environment
if ($env === 'development') {
    define('DB_HOST',     'localhost');
    define('DB_NAME',     'app_dev');
    define('LOG_LEVEL',   'debug');
    define('CACHE_TTL',   0);          // tidak ada cache di development
} else {
    define('DB_HOST',     '10.0.1.5');
    define('DB_NAME',     'app_prod');
    define('LOG_LEVEL',   'error');
    define('CACHE_TTL',   3600);       // 1 jam di production
}

echo DB_HOST;   // localhost atau 10.0.1.5, tergantung environment

<?php
define('STATUS_VALID', [
    'aktif',
    'pending',
    'terverifikasi',
]);

define('HTTP_CODES', [
    200 => 'OK',
    301 => 'Moved Permanently',
    400 => 'Bad Request',
    401 => 'Unauthorized',
    403 => 'Forbidden',
    404 => 'Not Found',
    500 => 'Internal Server Error',
]);

echo HTTP_CODES[404]; // Not Found

if (in_array($status, STATUS_VALID)) {
    // proses...
}

<?php
// ✓ Nilai yang valid untuk const
const APP_VERSION    = '2.1.0';
const MAX_RETRY      = 3;
const PI             = 3.14159265;
const ENABLE_FEATURE = true;
const EMPTY_ARRAY    = [];

// Ekspresi konstan diperbolehkan sejak PHP 5.6
const MAX_UPLOAD_BYTES = 10 * 1024 * 1024; // 10 MB — operator aritmatika OK
const TIMEOUT_MS       = 30 * 1000;        // 30 detik dalam milidetik

// ✗ Nilai yang TIDAK valid untuk const — akan menyebabkan parse error
// const TIMESTAMP = time();      // pemanggilan fungsi tidak diperbolehkan
// const HOST      = $dbHost;     // variabel tidak diperbolehkan
// const PREFIX    = strtolower('APP_'); // fungsi tidak diperbolehkan

<?php
// const tidak bisa di dalam blok kondisional
if (true) {
    // const SALAH = 'ini error'; // Fatal error: const declarations...
    define('BENAR', 'ini ok');    // define() bisa di mana saja
}

// const di level global mengikuti namespace
namespace App\Config;

const VERSION = '1.0'; // fullname-nya adalah App\Config\VERSION

// Akses dari luar namespace:
echo \App\Config\VERSION;

// define() selalu global terlepas dari namespace
define('GLOBAL_KEY', 'nilai'); // selalu App\Config\GLOBAL_KEY? Tidak!
                                // ini tetap GLOBAL_KEY di global namespace

<?php
class OrderStatus
{
    const PENDING    = 'pending';
    const PROCESSING = 'processing';
    const SHIPPED    = 'shipped';
    const DELIVERED  = 'delivered';
    const CANCELLED  = 'cancelled';
    const REFUNDED   = 'refunded';

    // Konstanta bisa berupa array
    const TERMINAL_STATUSES = [
        self::DELIVERED,
        self::CANCELLED,
        self::REFUNDED,
    ];

    // Method bisa menggunakan konstanta kelas sendiri
    public static function isTerminal(string $status): bool
    {
        return in_array($status, self::TERMINAL_STATUSES, true);
    }
}

// Akses dari luar kelas menggunakan ::
echo OrderStatus::PENDING;     // pending
echo OrderStatus::SHIPPED;     // shipped

$status = 'delivered';
if (OrderStatus::isTerminal($status)) {
    echo "Order sudah selesai diproses";
}

// Di dalam kelas sendiri, gunakan self:: atau static::
class Order
{
    private string $status;

    public function isSelesai(): bool
    {
        return $this->status === OrderStatus::DELIVERED;
    }
}

<?php
class PaymentGateway
{
    // Public — bisa diakses dari mana saja
    public const VERSION         = '3.0';
    public const SUPPORTED_CARDS = ['visa', 'mastercard', 'jcb'];

    // Protected — hanya kelas ini dan turunannya
    protected const INTERNAL_KEY = 'secret-internal-key';
    protected const RETRY_DELAY  = 2; // detik

    // Private — hanya kelas ini
    private const ALGORITHM      = 'AES-256-CBC';
    private const IV_LENGTH      = 16;

    public function getAlgorithmInfo(): string
    {
        // Akses private constant di dalam kelas sendiri
        return self::ALGORITHM . ' (IV: ' . self::IV_LENGTH . ' bytes)';
    }
}

class MidtransGateway extends PaymentGateway
{
    public function retry(): void
    {
        // Akses protected constant dari turunan
        sleep(parent::RETRY_DELAY);
    }
}

echo PaymentGateway::VERSION;          // '3.0' — public OK
// echo PaymentGateway::ALGORITHM;     // Fatal Error — private
// echo PaymentGateway::INTERNAL_KEY;  // Fatal Error — protected

<?php
interface Cacheable
{
    // Konstanta di interface selalu public
    const DEFAULT_TTL = 3600;     // 1 jam
    const MAX_TTL     = 86400;    // 24 jam
    const NO_CACHE    = 0;

    public function getCacheKey(): string;
    public function getTtl(): int;
}

class ProductCache implements Cacheable
{
    public function getCacheKey(): string
    {
        return 'products:all';
    }

    public function getTtl(): int
    {
        return self::DEFAULT_TTL; // akses konstanta interface via self::
    }
}

// Akses lewat nama interface atau nama kelas implementor
echo Cacheable::DEFAULT_TTL;    // 3600
echo ProductCache::DEFAULT_TTL; // 3600 — sama

<?php
// Cara lama — class constant, tidak ada type safety
class StatusLama
{
    const AKTIF    = 'aktif';
    const NONAKTIF = 'nonaktif';
}

function ubahStatus(string $status): void // menerima string apa saja!
{
    // tidak ada yang mencegah pemanggil kirim 'apapun'
}

ubahStatus('aktif');      // OK
ubahStatus('sembarangan'); // juga OK secara type system, tapi salah logika!

// ---

// Cara modern — Pure Enum, type-safe
enum Status
{
    case Aktif;
    case Nonaktif;
    case Pending;
}

function ubahStatusV2(Status $status): void // hanya menerima nilai Status yang valid
{
    // compiler dan IDE tahu nilai apa yang valid
}

ubahStatusV2(Status::Aktif);      // ✓ OK
// ubahStatusV2('aktif');          // ✗ TypeError — string bukan Status
// ubahStatusV2(Status::Hapus);    // ✗ Error — Hapus tidak ada di enum

<?php
// String-backed enum
enum OrderStatus: string
{
    case Pending    = 'pending';
    case Processing = 'processing';
    case Shipped    = 'shipped';
    case Delivered  = 'delivered';
    case Cancelled  = 'cancelled';

    // Method bisa di-attach langsung ke enum
    public function label(): string
    {
        return match($this) {
            OrderStatus::Pending    => 'Menunggu Pembayaran',
            OrderStatus::Processing => 'Sedang Diproses',
            OrderStatus::Shipped    => 'Dalam Pengiriman',
            OrderStatus::Delivered  => 'Terkirim',
            OrderStatus::Cancelled  => 'Dibatalkan',
        };
    }

    public function isTerminal(): bool
    {
        return in_array($this, [
            self::Delivered,
            self::Cancelled,
        ], true);
    }

    public function canTransitionTo(OrderStatus $next): bool
    {
        return match($this) {
            self::Pending    => $next === self::Processing || $next === self::Cancelled,
            self::Processing => $next === self::Shipped    || $next === self::Cancelled,
            self::Shipped    => $next === self::Delivered,
            default          => false, // terminal status tidak bisa transisi
        };
    }
}

// Penggunaan
$status = OrderStatus::Pending;
echo $status->value;             // pending — nilai yang disimpan ke DB
echo $status->name;              // Pending — nama case
echo $status->label();           // Menunggu Pembayaran

// Buat dari nilai (misal dari database)
$dariDb    = OrderStatus::from('shipped');          // OrderStatus::Shipped
$dariDbAlt = OrderStatus::tryFrom('tidak_ada');     // null (tidak throw error)

// Cek transisi yang valid
$bisa = OrderStatus::Pending->canTransitionTo(OrderStatus::Processing); // true
$bisa = OrderStatus::Pending->canTransitionTo(OrderStatus::Shipped);    // false

<?php
// Integer-backed enum — berguna untuk kode HTTP, role level, dsb
enum HttpStatus: int
{
    case Ok                 = 200;
    case Created            = 201;
    case BadRequest         = 400;
    case Unauthorized       = 401;
    case Forbidden          = 403;
    case NotFound           = 404;
    case InternalError      = 500;

    public function isSuccess(): bool
    {
        return $this->value >= 200 && $this->value < 300;
    }

    public function isClientError(): bool
    {
        return $this->value >= 400 && $this->value < 500;
    }
}

function kirimResponse(HttpStatus $status, mixed $data): void
{
    http_response_code($status->value);
    echo json_encode([
        'status'  => $status->value,
        'success' => $status->isSuccess(),
        'data'    => $data,
    ]);
}

kirimResponse(HttpStatus::Ok, ['user' => 'Budi']);
kirimResponse(HttpStatus::NotFound, null);

<?php
// Penggunaan praktis konstanta magic

// Menentukan path relatif dari lokasi file saat ini
$configPath = __DIR__ . '/config/database.php';
require_once $configPath; // selalu benar terlepas dari mana script dipanggil

// Logging yang otomatis menyebut lokasi error
function log(string $pesan, string $level = 'info'): void
{
    $timestamp = date('Y-m-d H:i:s');
    $caller    = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1)[0];
    $lokasi    = $caller['file'] . ':' . $caller['line'];
    file_put_contents(
        __DIR__ . '/storage/logs/app.log',
        "[$timestamp][$level] $pesan — $lokasi\n",
        FILE_APPEND
    );
}

<?php
// Informasi versi dan environment
echo PHP_VERSION;           // "8.3.x"
echo PHP_MAJOR_VERSION;     // 8
echo PHP_MINOR_VERSION;     // 3
echo PHP_OS;                // "Linux", "WINNT", "Darwin"
echo PHP_OS_FAMILY;         // "Linux", "Windows", "BSD", "Darwin"
echo PHP_SAPI;              // "cli", "apache2handler", "fpm-fcgi"
echo PHP_EOL;               // "\n" di Unix, "\r\n" di Windows
echo PHP_INT_MAX;           // 9223372036854775807 (64-bit)
echo PHP_INT_MIN;           // -9223372036854775808
echo PHP_FLOAT_MAX;         // 1.7976931348623E+308
echo PHP_FLOAT_EPSILON;     // 2.2204460492503E-16

// Separator path — berguna untuk path yang lintas OS
echo DIRECTORY_SEPARATOR;   // "/" di Unix, "\" di Windows
echo PATH_SEPARATOR;        // ":" di Unix, ";" di Windows

// Gunakan konstanta ini untuk kode yang portabel antar OS
$path = __DIR__ . DIRECTORY_SEPARATOR . 'storage' . DIRECTORY_SEPARATOR . 'cache';

<?php
// Boolean dan null sudah ada sebagai konstanta bawaan
var_dump(TRUE);   // bool(true)
var_dump(FALSE);  // bool(false)
var_dump(NULL);   // NULL

// Konstanta matematika
echo M_PI;        // 3.1415926535898 — nilai π
echo M_E;         // 2.718281828459  — bilangan Euler
echo M_SQRT2;     // 1.4142135623731 — akar 2
echo INF;         // INF — tak terhingga
echo NAN;         // NAN — Not a Number

var_dump(is_nan(sqrt(-1)));   // bool(true)
var_dump(is_infinite(log(0))); // bool(true)

// Filter dan flag untuk fungsi bawaan
$html    = '<script>alert("xss")</script>';
$aman    = htmlspecialchars($html, ENT_QUOTES | ENT_HTML5, 'UTF-8');
// ENT_QUOTES dan ENT_HTML5 adalah konstanta integer

// SORT flags untuk sorting
$data = ['10', '9', '100'];
sort($data);                       // ['10', '100', '9'] — sort string
sort($data, SORT_NUMERIC);         // ['9', '10', '100'] — sort numerik
sort($data, SORT_NATURAL);         // sort alami seperti file explorer

<?php
// Cek apakah konstanta sudah didefinisikan
if (!defined('APP_ENV')) {
    define('APP_ENV', 'production');
}

// Ambil nilai konstanta dari nama string (dinamis)
$namaKonstanta = 'PHP_VERSION';
echo constant($namaKonstanta); // "8.3.x" — sama seperti echo PHP_VERSION

// Daftar semua konstanta yang didefinisikan user (bukan bawaan PHP)
$konstantaUser = get_defined_constants(true)['user'];
foreach ($konstantaUser as $nama => $nilai) {
    echo "$nama = " . var_export($nilai, true) . "\n";
}

// Daftar semua konstanta termasuk bawaan PHP
$semuaKonstanta = get_defined_constants();
// array sangat panjang — lebih dari 1000 konstanta bawaan PHP

<?php
// ✗ Anti-pattern 1: Konstanta sebagai pengganti konfigurasi yang harusnya di .env
define('DB_PASSWORD', 'password123'); // password di kode sumber — bahaya!

// ✓ Solusi: baca dari environment variable
define('DB_PASSWORD', getenv('DB_PASSWORD') ?: throw new \RuntimeException(
    'DB_PASSWORD environment variable tidak di-set'
));

// ---

// ✗ Anti-pattern 2: Nama konstanta yang terlalu generik
define('MAX', 100);     // max apa?
define('HOST', 'localhost'); // host untuk apa?
define('KEY', 'abc123');    // key apa?

// ✓ Solusi: nama yang spesifik dan self-describing
define('MAX_LOGIN_ATTEMPTS',    5);
define('REDIS_HOST',            'localhost');
define('JWT_SECRET_KEY',        getenv('JWT_SECRET'));

// ---

// ✗ Anti-pattern 3: Gunakan class constant untuk sekumpulan status,
//    tapi kemudian harus validasi manual
class Status
{
    const AKTIF    = 1;
    const NONAKTIF = 2;
    const PENDING  = 3;
}

function setStatus(int $status): void
{
    // Tidak ada jaminan $status adalah salah satu dari Status::*
    // Seseorang bisa panggil setStatus(999) dan tidak ada error
    $this->status = $status;
}

// ✓ Solusi PHP 8.1+: gunakan enum untuk type safety
enum Status: int
{
    case Aktif    = 1;
    case Nonaktif = 2;
    case Pending  = 3;
}

function setStatusV2(Status $status): void
{
    // Compiler memastikan hanya nilai Status yang valid bisa masuk
    $this->status = $status->value;
}

// ---

// ✗ Anti-pattern 4: Konstanta yang sebenarnya butuh dihitung
define('CACHE_EXPIRE_TOMORROW', strtotime('tomorrow')); // nilai berubah tiap hari!
// Ini bukan konstanta — nilainya berbeda setiap kali script dijalankan

// ✓ Solusi: gunakan fungsi atau property yang dihitung saat dibutuhkan
function getCacheExpireTomorrow(): int
{
    return strtotime('tomorrow midnight');
}

// ---

// ✗ Anti-pattern 5: Duplikasi konstanta yang sama di banyak kelas
class UserController
{
    const PER_PAGE = 20;
}
class ProductController
{
    const PER_PAGE = 20; // duplikat! ubah satu harus ubah semua
}

// ✓ Solusi: konstanta bersama di satu tempat
class Pagination
{
    const DEFAULT_PER_PAGE = 20;
    const MAX_PER_PAGE     = 100;
}

class UserController
{
    public function index(): void
    {
        $perPage = Pagination::DEFAULT_PER_PAGE;
    }
}