English
English
In PHP, constants are a very important concept, and their values during script execution are not alterable. Usually, constants are used to store some fixed configuration values, such as database connection information, system paths, API keys, etc. The get_defined_constants() function can help us get all the currently defined constants.
However, when we have a large number of constants that need to be read frequently, each access to the constant requires a certain overhead, especially in larger systems, performance improvements become particularly important. In order to improve the performance of the program and avoid reading the definition of constants every time, we can create a cache system through the get_defined_constants() function to store the state of constants, reducing unnecessary repeated calculations, thereby improving the performance of the system.
The get_defined_constants() function is a built-in function in PHP that returns an associative array containing all defined constants and their values. The syntax of this function is as follows:
array get_defined_constants(bool $categorize = false);
The $categorize parameter determines whether the returned array is grouped by category. If set to true , it will be returned by the category of the constants; if false (default), it will return a flat array containing all constants.
To improve performance, we can use the get_defined_constants() function to create a cache system. We store constants in a cache file and read directly from the cache file the next time we access it, instead of computing it via get_defined_constants() again.
First, we need to make sure there is a directory for storing caches. For example, you can create a folder called cache in the root directory of the project to store constant caches.
$cacheDir = __DIR__ . '/cache/';
if (!file_exists($cacheDir)) {
mkdir($cacheDir, 0777, true);
}
Before getting the constant, we can check whether a cache file already exists. If the cache file exists and has not expired, then the constants in the cache are loaded directly; otherwise, get_defined_constants() is called again and the result is cached.
$cacheFile = $cacheDir . 'constants_cache.php';
if (file_exists($cacheFile) && (filemtime($cacheFile) > (time() - 3600))) {
// The cache file exists and does not expire within one hour，Directly load the cache
$constants = include($cacheFile);
} else {
// The cache file does not exist or has expired，Re-get constants and cache
$constants = get_defined_constants();
file_put_contents($cacheFile, '<?php return ' . var_export($constants, true) . ';');
}
Once the constant is cached, we can use the constants in the cache directly wherever we need it. For example, when dealing with constants, we can get the value of a constant through simple array access.
echo $constants['MY_CONSTANT']; // Output MY_CONSTANT Value of
To avoid cache files taking up too much disk space, we can clean cache files regularly. You can use the unlink() function to delete the cache file, or clear the cache under specific conditions.
// Clear cache
unlink($cacheFile);
Here is a complete PHP example showing how to create a simple cache system using get_defined_constants() :
<?php
$cacheDir = __DIR__ . '/cache/';
$cacheFile = $cacheDir . 'constants_cache.php';
// Create a cache directory（If it does not exist）
if (!file_exists($cacheDir)) {
mkdir($cacheDir, 0777, true);
}
// Check if the cache file exists and is valid
if (file_exists($cacheFile) && (filemtime($cacheFile) > (time() - 3600))) {
// The cache file exists and does not expire within one hour，Directly load the cache
$constants = include($cacheFile);
} else {
// The cache file does not exist or has expired，Re-get constants and cache
$constants = get_defined_constants();
file_put_contents($cacheFile, '<?php return ' . var_export($constants, true) . ';');
}
// Use constants in cache
echo isset($constants['MY_CONSTANT']) ? $constants['MY_CONSTANT'] : 'Constants do not exist';
?>
By leveraging the get_defined_constants() function, we can easily get all constants in PHP scripts. By caching the state of constants, we can avoid calculating constants from scratch every time, thereby improving the performance of the application. This caching strategy is ideal for scenarios where constant values need to be read frequently.
Through the above steps, you can simply implement a constant cache system, which can improve performance while reducing unnecessary computing overhead. If you encounter performance bottlenecks when building large projects, consider using this approach to optimize the management of constants.
