Dynamic constant parsing can be implemented through defined() and constant() functions. First, use defined() to check whether the constant exists, and then use constant() to obtain its value to avoid undefined errors. 1. defined('CONST_NAME') returns a boolean value, used to determine whether the constant has been defined, and a constant name string must be passed in. 2. constant('CONST_NAME') returns the value of the corresponding constant and supports dynamic splicing names. 3. Practical applications include: multi-environment configuration management, automatically loading the corresponding configuration through environment variable splicing constant names; dynamic reading of module constants in the plug-in system; and combining encapsulation functions to achieve default value fallback. 4. Note: Constant names are case sensitive by default; constant() triggers E_WARNING when the constant is not defined, so it must be checked with defined() first; it is not applicable to const definition in the class, and class constants need to be accessed through ReflectionClass or scope operators. Summary: The core mode of dynamic constant analysis is to judge first and then read, which is suitable for configuration switching, modular design and flexible configuration abstraction layer construction, and to fully realize safe and efficient dynamic access of constants.

In PHP, dynamic constant resolution is a relatively useless but very practical feature, especially when dealing with configuration, multi-environment constants, or plug-in systems. With defined() and constant() functions, we can safely check whether a constant exists and get its value dynamically at runtime, thus avoiding triggering errors due to accessing undefined constants.

The following is a detailed introduction to how these two functions work together to implement dynamic constant resolution (Dynamic Constant Resolution) .

1. defined() : Check whether the constant exists

defined(string $constant_name): bool is used to determine whether a constant has been defined.

 if (defined('APP_ENV')) {
    echo 'Environment has been set:' . APP_ENV;
} else {
    echo 'Environment is not defined';
}

You can also use it to check the dynamically generated constant names:

 $prefix = 'CONFIG';
$name = $prefix . '_TIMEOUT';

if (defined($name)) {
    echo constant($name);
} else {
    echo "Constant $name undefined";
}

?? Note: defined() receives string form of constant name , rather than writing constants directly (such as defined(CONFIG_TIMEOUT) is wrong, it should be defined('CONFIG_TIMEOUT') ).

2. constant() : dynamically obtain constant values

constant(string $constant_name): mixed allows you to get the value of a constant by string name, which is very suitable for dynamic scenarios.

 define('SITE_NAME', 'MyWebsite');
define('SITE_DEBUG', true);

$setting = 'SITE_NAME';
echo constant($setting); // Output: MyWebsite

Combined with variable splicing, more flexible configuration reading can be achieved:

 $section = 'DATABASE';
$key = 'HOST';

$constName = "{$section}_{$key}"; // DATABASE_HOST

if (defined($constName)) {
    $value = constant($constName);
    echo "Database Host: $value";
} else {
    echo "Configuration not found: $constName";
}

3. Practical application scenarios

? Configuration Management (Multiple Environment)

For example, development, testing, and production environments use different constants:

 $env = $_ENV['APP_ENV'] ?? 'DEV';

$configKeys = ['HOST', 'USER', 'PASS', 'DB'];

$config = [];
foreach ($configKeys as $key) {
    $constName = "DB_{$env}_{$key}";
    if (defined($constName)) {
        $config[strtolower($key)] = constant($constName);
    }
}

This way, the corresponding constant configuration can be automatically loaded according to the environment.

? Plug-in or modular system

Some plugins may define their own prefix constants, which can be read dynamically by the main program:

 $plugin = 'PAYPAL';
if (defined("{$plugin}_VERSION")) {
    $version = constant("{$plugin}_VERSION");
    echo "Plugin{$plugin} version: $version";
}

? Default value fallback

 function getConstant(string $name, $default = null) {
    return defined($name) ? constant($name) : $default;
}

// Use $timeout = getConstant('REQUEST_TIMEOUT', 30);

4. Things to note

• Constant names are case sensitive (unless define('name', value, true) is set to indistinguishable, but the usage is deprecated).
• constant() will trigger E_WARNING when the constant is undefined, so be sure to use defined() to judge first .
• Not applicable to const definitions in a class (that is a class constant). To access a class constant, you need to use ReflectionClass or ::class::CONST syntax.

Summarize

Use defined() and constant() to safely implement dynamic constant parsing, which is particularly suitable for:

• Multi-environment configuration switching
• Dynamic load module settings
• Build a flexible configuration abstraction layer

The key mode is:

 $constName = 'DYNAMIC_NAME';
if (defined($constName)) {
    $value = constant($constName);
    // Use $value
}

Basically all this is not complicated but easy to ignore.

The above is the detailed content of Dynamic Constant Resolution with `defined()` and the `constant()` Function. For more information, please follow other related articles on the PHP Chinese website!