Constants in PHP - Complete Beginner's Guide

Note: This information applies to modern PHP 8+. Some behavior differs in older versions.

How to Define Constants in PHP

const — Preferred, Compiled at Load Time

• Syntax: const NAME = CONSTANT_EXPRESSION;
• Works at file level (global) and in classes/interfaces.
• Value must be known at compile time (numbers, strings, constant arrays, and operations on them).

define() — Defined at Runtime

• Syntax: define('NAME', $value);
• Works at runtime (can be used inside conditions, functions, loops).
• Useful for dynamic constant names.
• In namespaces, by default creates a global constant (unless you specify the full name with backslashes).

Class Constants

• Syntax: public const NAME = value;
• Since PHP 7.1, class constants can have visibility modifiers (public/protected/private).
• Since PHP 8.1, you can use final const to prevent overriding in child classes.

PHP Code Examples

1) Basic Global Constants: const and define

<?php
// Simple constant — const (preferred)
const APP_NAME = 'MyApplication';
const APP_VERSION = '1.0.0';

// define() — works at runtime
define('DEBUG_MODE', true);

// Using constants
echo APP_NAME . ' v' . APP_VERSION . PHP_EOL; // "MyApplication v1.0.0"
if (DEBUG_MODE) {
    echo "Debug mode enabled" . PHP_EOL;
}

2) Constants and Modification Attempt (Error)

<?php
const LIMIT = 100;

// The following line causes a Fatal error:
// LIMIT = 200;

echo LIMIT; // 100

3) Constant Arrays and Constant Expressions

<?php
// Array as a constant (PHP 5.6+)
const DEFAULT_ROLES = ['USER', 'MODERATOR', 'ADMIN'];

// Constant built from other constants
const BASE_DIR = __DIR__;
const PUBLIC_DIR = BASE_DIR . '/public';

print_r(DEFAULT_ROLES);
echo PUBLIC_DIR; // e.g., "/var/www/project/public"

Note: const cannot use function calls in its value (except built-in magic constants like __DIR__). define() can take the result of any function, since it works at runtime.

4) define() with Dynamic Name and Access via constant()

<?php
$env = 'PROD';
define("API_URL_$env", 'https://api.example.com');

// Access by string name
$constName = "API_URL_$env";
echo constant($constName); // "https://api.example.com"

// Check if constant exists
if (defined($constName)) {
    echo "Defined $constName";
}

5) Constants in Namespaces

<?php
namespace App\Config;

// Creates a constant in App\Config
const TIMEOUT = 30;

// WARNING: define() without full name creates a GLOBAL constant:
define('TIMEOUT_GLOBAL', 45);

// define() with full name (PHP 5.3+)
define('App\\Config\\RETRIES', 3);

echo \App\Config\TIMEOUT;    // 30
echo \TIMEOUT_GLOBAL;        // 45 (global)
echo \App\Config\RETRIES;    // 3

6) Class Constants (Scope and Inheritance)

<?php
class HttpClient
{
    public const DEFAULT_TIMEOUT = 10;        // public
    protected const DEFAULT_HEADERS = ['Accept' => 'application/json'];

    // Since PHP 8.1: prevent overriding
    // final public const VERSION = '2.0';
}

class CustomHttpClient extends HttpClient
{
    // Redefining a constant with the same name is possible
    // (depending on version and final restriction), but usually bad practice:
    public const DEFAULT_TIMEOUT = 15;
}

echo HttpClient::DEFAULT_TIMEOUT;      // 10
echo CustomHttpClient::DEFAULT_TIMEOUT; // 15

7) Magic Constants — Useful in Practice

<?php
echo __FILE__ . PHP_EOL;       // Full path to this file
echo __DIR__ . PHP_EOL;        // Current file directory
echo __LINE__ . PHP_EOL;       // Current line number
echo __FUNCTION__ . PHP_EOL;   // Function name (inside a function)
echo __CLASS__ . PHP_EOL;      // Class name (inside a class)
echo __METHOD__ . PHP_EOL;     // Class::method (inside a method)
echo __NAMESPACE__ . PHP_EOL;  // Current namespace

8) Practical Example: Config Paths and Logic

<?php
// config.php
const ROOT_PATH   = __DIR__;
const STORAGE_DIR = ROOT_PATH . '/storage';
const LOGS_DIR    = STORAGE_DIR . '/logs';
const TMP_DIR     = STORAGE_DIR . '/tmp';

const APP_ENV     = 'production'; // 'local', 'staging', 'production'
const APP_DEBUG   = (APP_ENV !== 'production');

function logger(string $message): void {
    $file = LOGS_DIR . '/app.log';
    $line = '[' . date('Y-m-d H:i:s') . '] ' . $message . PHP_EOL;
    // In real code add file error handling
    file_put_contents($file, $line, FILE_APPEND);
}

if (APP_DEBUG) {
    logger('Application running in debug mode.');
}

echo "Logs: " . LOGS_DIR . PHP_EOL;

9) Typical Errors — Redefinition and Name Collisions

<?php
const RATE = 1.23;

// Attempt to redefine:
if (!defined('RATE')) {
    // This block won’t execute, because const is resolved at compile time,
    // and defined('RATE') checks global constants defined via define().
    // For const in namespaces, check with the full name.
}

// define() will warn if constant already exists:
define('RATE', 2.0); // Warning: constant already defined

Safer approach:

<?php
if (!defined('APP_STARTED')) {
    define('APP_STARTED', true);
    // ... safe initialization, runs only once
}

Best Practices and Common Mistakes

Best Practices

• Use const whenever possible:

• Use built-in PHP constants:

• Check existence before define() if code may run multiple times:

• For environment-specific configs, consider:

What to Avoid (Common Mistakes)

• Overusing global constants to pass data between modules. This makes testing harder and increases coupling. Instead, pass dependencies to functions/classes.
• Defining constants in multiple places with inconsistent naming — risks collisions and confusion.
• Relying on old, unsupported define() case-insensitive option. Since PHP 8+, constants are always case-sensitive. Stick to one naming convention.
• Using const in blocks where not allowed (e.g., inside functions for global constants) — const only works at file/namespace level and in classes.
• Trying to reassign or unset constants — not possible.

Summary

• Constants in PHP are named values that cannot be changed after definition.
• Main declaration methods: