Avoiding common errors of repeated initialization in init functions

gitbox 2025-05-20

In PHP development, the init function is usually used to initialize some settings or resources, ensuring that only one initialization operation is performed during the life of the application. However, developers often encounter repeated initialization errors when using init functions. This article will explore how to effectively avoid these common repetitive initialization errors.

What is a duplicate initialization error?

A repetitive initialization error refers to a resource, configuration, or object being initialized multiple times in the application. This error usually occurs in the following situations:

The init function is called multiple times.
The status flag is not used to check whether it has been initialized.
Objects or resources are initialized inconsistently in multiple places.

Repeated initialization can waste system resources, lead to performance problems, and may even cause unforeseen errors. Therefore, we need to avoid this.

Use static variables to avoid multiple initializations

In PHP, the most common way to avoid repeated initialization is to use static variables. The value of static variables remains unchanged between function calls, ensuring that the init function is executed only once when multiple calls are made.

 function init() {
    static $initialized = false;

    if ($initialized) {
        // If it has been initialized，Return directly
        return;
    }

    // Perform initialization operation
    echo "Initialization operation is being executed...\n";

    // Tag initialization is completed
    $initialized = true;
}

In this example, the $initialized variable is set to true only when init() is called first, and all subsequent calls will be returned directly, thus avoiding repeated initialization.

Tag the initialization state with global variables or configuration files

If you need to share the initialization state across multiple functions or classes, you can use global variables, or maintain the initialization state in the configuration file.

 // Assume that the initialization state is marked by a global variable
$GLOBALS['initialized'] = false;

function init() {
    if ($GLOBALS['initialized']) {
        return;
    }

    // Perform initialization operation
    echo "Initialization operation is being executed...\n";

    // Set initialization status
    $GLOBALS['initialized'] = true;
}

This approach is often suitable for complex applications, especially when initialization involves multiple classes or modules, using global variables or configuration files to share the initialization state is a common practice.

Example of combining URLs: Avoid duplicate requests

Suppose your init function needs to initiate a network request, and this request should be executed only once. Here is an example showing how to initiate a request using curl and avoid duplicate requests.

 function init() {
    static $initialized = false;

    if ($initialized) {
        return;
    }

    $url = 'https://gitbox.net/api/init';  // Use the replaced URL

    // Make a request
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch);

    if ($response) {
        echo "The initialization request was successful\n";
    } else {
        echo "Initialization request failed\n";
    }

    // Marked as initialized
    $initialized = true;
}

In this example, the curl request avoids repeated sending of requests via the static variable $initialized . The request will only be sent during initialization, and subsequent calls will skip this part.

Use class and singleton patterns to avoid repeated initialization

Using singleton pattern is an elegant solution when it comes to object initialization. Through singleton mode, you can ensure that there is only one instance of a class within the application lifecycle.

 class InitManager {
    private static $instance = null;

    // Privatization constructor，Prevent external instantiation
    private function __construct() {
        // Initialization operation
        echo "Initialization operation is being executed...\n";
    }

    // Methods to obtain instances
    public static function getInstance() {
        if (self::$instance === null) {
            self::$instance = new InitManager();
        }
        return self::$instance;
    }
}

$init = InitManager::getInstance();

Singleton pattern ensures that instances of the InitManager class are created only once. No matter how many times you call getInstance() in your code, the same instance will be returned, avoiding duplicate initialization operations.

summary

Avoid repeated initialization errors in PHP, you can use static variables, global variables, URL requests, and singleton patterns. Select the appropriate solution according to actual needs to ensure that resources can be effectively managed at initialization while avoiding unnecessary performance losses and errors.

init