PHP Constants

PHP

PHP Constants - Define and Use Constants

In PHP, constants are a fundamental concept used to store fixed values that do not change during the execution of a script. Unlike variables, constants once defined cannot be altered or undefined. This tutorial will guide you through everything you need to know about PHP constants — from their definition using both define() function and the const keyword, to best practices and common pitfalls to avoid. Additionally, we will explore magic constants, interview questions about PHP constants, and frequently asked questions.

Prerequisites

  • Basic understanding of PHP syntax and concepts
  • PHP installed on your machine (version 5.3+ recommended for modern features)
  • A text editor or IDE (e.g., VS Code, PHPStorm)
  • Basic understanding of variables and data types in PHP

Setting Up Your Environment

To work with PHP constants, you will need:

  1. Install PHP: Download and install PHP from php.net.
  2. Set up a text editor or IDE.
  3. Create a new PHP file, for example, constants.php.
  4. Ensure your PHP environment is running — local server (XAMPP, MAMP) or command line.

What Are PHP Constants?

A constant is an identifier (name) for a simple value that cannot change during the execution of a script. Constants are globally accessible and do not use the $ symbol as variables do.

Features of PHP Constants

  • Immutable: Values cannot be changed once set.
  • Global scope: Available throughout the script after definition.
  • Stored value types: Integer, string, boolean, float, array (PHP 7+), resources not allowed.
  • Can be scalar or array (array constants introduced in PHP 7).

Defining Constants in PHP

1. Using define() Function

The most common way to define a constant in PHP is using the define() function.

define('CONSTANT_NAME', 'constant value');

Example:

define('SITE_NAME', 'My Awesome Website');
echo SITE_NAME; // Outputs: My Awesome Website

Points to Remember

  • Constant names are case-sensitive by default. To create case-insensitive constants, pass true as the third argument in PHP 7.3 and earlier (deprecated in PHP 8+).
  • Constants do not begin with a $ symbol.
  • Allowed values: scalar values, arrays (PHP 7+).

2. Using const Keyword

Since PHP 5.3, you can define constants using the const keyword inside or outside classes. const works only with constant scalar values and cannot use expressions or function calls.

const PI = 3.14159;
echo PI; // Outputs: 3.14159

Inside classes:

class Circle {
    const PI = 3.14159;
    public function getPi() {
        return self::PI;
    }
}
$c = new Circle();
echo $c->getPi(); // Outputs: 3.14159

Differences Between define() and const

  • const is a language construct evaluated at compile time; define() is a runtime function.
  • const cannot be used inside conditional blocks; define() can.
  • const can be used to define constants inside classes; define() cannot.
  • const supports only scalar types.

Magic Constants in PHP

These are special predefined constants that change depending on where they are used.

  • __LINE__: Current line number of the file.
  • __FILE__: Full path and filename of the file.
  • __DIR__: Directory of the file.
  • __FUNCTION__: Function name.
  • __CLASS__: Current class name.
  • __METHOD__: Class method name.
  • __NAMESPACE__: Current namespace.
echo "This line is " . __LINE__;
echo "This file is " . __FILE__;

Examples Explained

Example 1: Simple Constant

define('VERSION', '1.0.0');
echo 'Application Version: ' . VERSION;

Output: Application Version: 1.0.0

Example 2: Using const keyword in a Class

class Config {
    const DB_HOST = 'localhost';
    const DB_USER = 'root';
}
echo Config::DB_HOST; // Outputs: localhost

Example 3: Magic constants usage

function demo() {
    echo "Function: " . __FUNCTION__ . ", Line: " . __LINE__;
}
demo();

Best Practices When Using PHP Constants

  • Use uppercase letters and underscores for constant names for clarity and convention.
  • Prefer const inside classes for better performance and readability.
  • Use define() for conditionally defined constants or dynamic names.
  • Do NOT attempt to change a constant's value once defined—show clear separation of mutable and immutable data.
  • Use Magic Constants appropriately to debug or obtain file/class/function information.

Common Mistakes to Avoid

  • Using a variable with constants: Constants must not have the $ prefix.
  • Trying to redefine constants: Once defined, constant values cannot be changed or undefined.
  • Incorrect usage of case-insensitive constants: Case-insensitive constants are deprecated as of PHP 8.0.
  • Using const inside conditional statements: Not allowed — leads to parse errors.
  • Using functions or expressions in const definitions: Not supported; use define() for dynamic values.

Interview Questions About PHP Constants

Junior Level

  • Q1: What is the difference between a constant and a variable in PHP?
    A1: Constants hold fixed values that cannot be changed once set, while variables can be reassigned during script execution.
  • Q2: How do you define a constant using the define() function?
    A2: Use define('CONSTANT_NAME', 'value'); where the name is a string without a $.
  • Q3: Can you use variables in the name when defining constants with define()?
    A3: Yes, because define() accepts dynamic names as strings.
  • Q4: What symbol prefix is used with constants in PHP?
    A4: None, constants do not use the $ prefix.
  • Q5: Are constants case-sensitive?
    A5: Yes, by default, constants are case-sensitive.

Mid Level

  • Q1: When should you use the const keyword over define()?
    A1: Use const for defining constants in classes and when values are scalar and known at compile time.
  • Q2: Can you define an array constant? How?
    A2: Yes, from PHP 7 onwards, using define('ARRAY_CONST', [1, 2, 3]);.
  • Q3: What are magic constants and give two examples?
    A3: Special predefined constants like __FILE__ and __LINE__ that change depending on where they're used.
  • Q4: Can const be used inside conditional blocks?
    A4: No, const declarations must be at the top-level or inside classes but not inside conditions.
  • Q5: Is it possible to make case-insensitive constants?
    A5: It was possible with define() by passing true parameter but deprecated in PHP 8+ and not recommended.

Senior Level

  • Q1: Explain the difference in runtime behavior between const and define().
    A1: const is resolved at compile time while define() happens at runtime, allowing dynamic constant names.
  • Q2: Can magic constants be overridden or redefined?
    A2: No, magic constants are read-only and predefined by PHP, cannot be changed by user code.
  • Q3: How would you implement conditional constants given the limitation of const declarations inside conditional blocks?
    A3: Use define() inside the conditional block or use class constants with separate classes for each condition.
  • Q4: Are constants autoloaded or do they require explicit definition on each script run?
    A4: Constants need to be defined explicitly in the script or included files; they're not autoloaded automatically like classes.
  • Q5: What are the limitations of const when defining complex constant expressions?
    A5: const cannot evaluate expressions, function calls, or concatenations; only scalar literals are supported.

Frequently Asked Questions (FAQ)

Can constants hold arrays in PHP?

Yes, since PHP 7, constants defined with define() can hold arrays.

Can I change the value of a constant once defined?

No, constants are immutable and their value cannot be changed once defined.

What is the difference between define() and const?

const is a compile-time construct and can be used in classes, while define() is a runtime function and allows dynamic names and conditional definitions.

Are PHP constants case-sensitive?

Yes, by default constants are case-sensitive. Case-insensitive constants are deprecated in PHP 8+.

What are magic constants useful for?

Magic constants provide information about the file, line, function, classname, or namespace, useful for debugging or metadata injection.

Conclusion

PHP constants are powerful for defining immutable data that should remain consistent throughout the lifecycle of your script. Whether you use define() or the const keyword, understanding their differences and best practices ensures both efficient and maintainable code. Magic constants add an additional layer of dynamism, allowing you to write more introspective and self-aware PHP scripts. Remember to avoid common pitfalls like redefining constants or misusing case-insensitive constants. With solid knowledge of PHP constants, you are better equipped to write reliable and clean PHP applications.