1. Configuration file description

In PHP development, configuration files are used to store application settings and configuration options so that the behavior of the application can be dynamically adjusted at runtime. Configuration files usually contain various environment variables, database connection information, log levels, cache settings, etc.

The role of the configuration file:

Separation of configuration and code: The configuration information is separated from the code, so that modifying the configuration does not require modifying the source code, thereby improving the maintainability of the code.
Dynamically modify application behavior: By modifying the value of the configuration file, the behavior of the application can be dynamically changed without recompiling or redeploying the code.
Multi-environment support: Different configuration options for multiple environments (such as development environment, test environment, and production environment) can be supported through configuration files.

Configuration file usage:

Create configuration file: Create a text file, usually using .php, .ini, .jsonand other formats to save. The naming convention is usually config.phpor config.ini.

Define configuration options: Set various configuration options in the configuration file, stored in the form of key-value pairs. For example:

<?php
// config.php
return [
    'database' => [
        'hostname' => 'localhost',
        'username' => 'root',
        'password' => 'password',
        'database_name' => 'mydb'
    ],
    'cache' => [
        'enabled' => true,
        'ttl' => 3600
    ],
    'debug' => false
];

Load configuration in the application: In the entry file of the application or other places that need to read the configuration, load the configuration file into the code through the includeor function. requireFor example:
```
// index.php
$config = require 'config.php';

// 使用配置中的值
$hostname = $config['database']['hostname'];
$username = $config['database']['username'];
// ...
```
Use configuration options as needed: Use the loaded configuration options and use them at appropriate places in your application, such as connecting to a database, generating logs, setting cache, etc.

Precautions:

Sensitive information in configuration files (such as database passwords) should be kept as confidential as possible, and corresponding security measures (such as permission settings, encryption, etc.) should be taken.
To use different configuration files in multiple environments, you can load different configuration files by setting environment variables or judging according to the current environment.
The format of the configuration file can be selected according to different formats, such as PHP array, INI file, JSON file, etc. Choose the format that works for your application and team.
It is recommended to keep the configuration files in a separate folder with proper backup and version control so that the configuration can be easily restored or rolled back if needed.
For large projects, you can consider using configuration management tools (such as dotenv, Symfony Config, etc.) to manage and load configuration more conveniently.

2. Generation of configuration files

/*
 * 生成或更新配置文件
 * */
function update_config()
{
    
    
    /*
     * 配置文件
     * */
    $php_pre = "<?php if (!defined('lock')) {exit('Access Denied');}" . PHP_EOL;
    $config_con = $php_pre;

    //数据库系统配置表
    //$rs = $db->fetchall('config', '*');
    $rs = ["sys_name" => "漏刻有时", "sys_code" => "20230729011"];
    $config_con .= "\$lock_conf=" . array_to_string($rs) . ";";

    //默认短信服务商
    $config_con .= "\$lock_sms='alidayu';";
    //默认快递服务商
    $config_con .= "\$lock_exp='shunfeng';";

    //生成文件;
    write_file("./config.php", $config_con);
}

3. Write to the file

/*
 * 写入文件
 * $filename，文件名称，可以包含文件路径
 * $contents，文件内容
 * 正常写入，返回1，否则返回0
 * */
function write_file($filename, $contents)
{
    
    
    if ($fp = fopen($filename, "w")) {
    
    
        $contents = trim($contents) == '' ? ' ' : $contents;
        fwrite($fp, $contents);
        fclose($fp);
        return true;
    } else {
    
    
        return false;
    }
}

Fourth, the call of the configuration file

define('lock', TRUE);
require_once "config.php";
echo $lock_sms;

Five, array to string

When reading the data table, you need to convert the array, and the encapsulation function is as follows:

/*
 * 将数组转为一维数组形式的字符串
 * 格式：$str="array('a','b','c')";
*/

function array_to_string($array)
{
    
    
    $res = "array(";
    foreach ($array as $key => $val) {
    
    
        $res .= "'" . $val . "',";
    }
    return rtrim($res, ",") . ")";
}

Summarize

Using cache files in PHP has the following pros and cons:

profit:

Improve page loading speed: By caching frequently accessed page content into files, database queries and complex calculation operations can be reduced, thereby improving page loading speed and response time. Cache files can be output directly without executing corresponding logic.
Reduce server load: The use of cache files can reduce frequent access to server resources (such as databases, computing resources, etc.), thereby reducing server load. This is especially useful for high-traffic websites or applications, and can improve system performance and stability.
Improve scalability and concurrent processing capabilities: By caching files, you can better handle concurrent requests and improve the concurrent processing capabilities of the system. Each request can get content directly from the cache file without waiting for resources to be generated and processed, thereby improving overall scalability.

Disadvantages:

Data consistency: When the content of a page changes, using cache files may lead to data inconsistency. The contents of cache files may not be updated in time, displaying outdated information. Therefore, pay attention to data consistency when using cache files, such as using cache invalidation mechanisms or manually refreshing the cache.
Storage space overhead: Caching files requires additional storage space. If the cache file is large or the cache time is long, it may take up a lot of storage space, especially in large-scale applications. The relationship between storage space and performance needs to be weighed, and cache files should be cleaned or updated regularly.
Cache invalidation problem: If the validity period of the cache file is set unreasonably or improperly managed, it may cause the cache invalidation problem. A too long validity period may lead to staleness of cached data, while a too short validity period may frequently regenerate cache files, reducing performance benefits. The validity period of the cache needs to be set reasonably according to specific business requirements and data update frequency.
Cache update problem: When the data changes, the corresponding cache file needs to be updated manually. If not well managed and maintained, it may cause inconsistency between cached files and actual data. Therefore, when updating data, the corresponding cache files need to be updated at the same time to maintain consistency.

When using cache files, it is necessary to weigh the effectiveness, consistency, and storage overhead of the cache, and perform reasonable configuration and management according to specific conditions. It is also a good practice to regularly clean out expired or no longer used cache files to ensure cache effectiveness and system performance.

@ Leak sometimes

Practical Analysis of PHP Development (6): Generation and Calling of Configuration Files or Cache Files

Generation and calling of configuration files or cache files