Even if you develop a new large-scale PHP program, you will inevitably use global data, because some data will be used in different parts of your code. Some common global data include: program setting classes, database connection classes, user information, etc. There are many ways to make this data global data, the most commonly used of which is to use the "global" keyword declaration, which we will explain in detail later in the article.
The only disadvantage of using the "global" keyword to declare global data is that it is actually a very poor way of programming, and often leads to bigger problems later in the program, because global data separates your code. The code segments are all linked together, so if you change one part of the code, it may cause other parts to go wrong. So if there are many global variables in your code, then your entire program will be difficult to maintain.
This article will show how to prevent this global variable problem through different techniques or design patterns. Of course, first let's see how to use the "global" keyword for global data and how it works. Using global variables and the "global" keyword
PHP defines some "Superglobals" variables by default. These variables are automatically globalized and can be called anywhere in the program, such as $_GET and $_REQUEST, etc. They usually come from data or other external data, and using these variables usually does not cause problems because they are basically not writable.
But you can use your own global variables. Using the keyword "global" you can import global data into the local scope of a function. If you don't understand "variable usage scope", please refer to the relevant instructions in the PHP manual.
The following is a demonstration example using the "global" keyword:
The following is the quoted content:
<?php
$my_var = 'Hello World';
test_global();
function test_global() {
// Now in local scope
// the $my_var variable doesn't exist
// Produces error: "Undefined variable: my_var"
echo $my_var;
// Now let's important the variable
global $my_var;
// Works:
echo $my_var;
}
?＞
As you can see in the above example, the "global" keyword is used to import global variables. It looks like it works well and is simple, so why do we worry about using the "global" keyword to define global data?
Here are three good reasons:
1. Code reuse is almost impossible.
If a function depends on global variables, it is almost impossible to use this function in different environments. Another problem is that you can't extract this function and use it in other code.
2. Debugging and solving problems is very difficult.
Tracking a global variable is much more difficult than tracking a non-global variable. A global variable may be redefined in some obscure include file, and even if you have a very good program editor (or IDE) to help you, it may take you several hours to discover the problem.
3. It will be very difficult to understand these codes.
It is difficult for you to figure out where a global variable comes from and what it is used for. During the development process, you may know every global variable, but after about a year, you may forget at least some of them. At this time, you will regret that you used so many global variables.
So if we don't use global variables, what do we use? Let’s look at some solutions below.
Using Function Parameters
One way to stop using global variables is to simply pass the variable as a parameter to the function, as shown below:
The following is the content of the quote:
<?php
$var = 'Hello World';
test ($var);
function test($var) {
echo $var;
}
?＞
If you only need to pass a global variable, then this is a very good or even outstanding solution, but what if you want to pass many values?
For example, suppose we want to use a database class, a program settings class and a user class. In our code, these three classes are used in all components, so they must be passed to each component. If we use the function parameter method, we have to do this:
The following is the quoted content:
<?php
$db = new DBConnection;
$settings = new Settings_XML;
$user = new User;
test($db, $settings, $user);
function test(&$db, &$settings, &$user) {
// Do something
}
?>
Obviously, this is not worth it, and once we have new objects to add, we have to add one more function parameter to each function. So we need to use another way to solve it.