Common errors in using PHP variables include undefined variables, improper reference assignment, improper type comparison, and confusing global variables. 1. Ignoring that the undefined variable will cause an Notice error. You should use isset() or empty() to check; 2. Reference assignment modifications will affect other variables, and you should clean up unset() after the loop; 3. Using == will cause automatic type conversion, and you should use === for congruent judgments; 4. Global variables are prone to confusion, and it is recommended to avoid or encapsulate them into class attributes to improve code clarity.

The use of variables in PHP seems simple, but many developers (especially those who are just starting out) are prone to getting into trouble. The most common problem is that the function cannot be written out, but because of improper variable processing, it can lead to logical errors, performance problems and even security vulnerabilities. The following common mistakes are worth paying special attention to.

1. Ignore the case where the variable is not defined

In PHP, if you directly use an undefined variable, Notice: Undefined variable error will be triggered. Although this will not crash the script, it will affect the code robustness, especially when it is turned on strictly mode or production environments to expose problems.

Suggested practices:

• Before using variables, use isset() or empty() to check whether it exists
• Especially in scenarios such as form submission and array value acquisition

For example:

 // Error writing echo $username;

// Correct writing if (isset($username)) {
    echo $username;
} else {
    echo 'Username not set';
}

Some developments are used to suppress error prompts using @ such as echo @$username; but this is just a masking problem and is not recommended.

2. Incorrectly using reference assignment&

Reference assignment in PHP is implemented through & . Many people think it can improve performance or simplify operations, but if you don’t understand its mechanism, it can easily lead to unexpected results.

Common phenomena:

• Modify one variable, and the other variable also changes
• After traversing the array, the last element is retained as a reference state, affecting subsequent operations.

Look at this example:

 $a = 10;
$b = &$a;
$b = 20;
echo $a; // Output 20

Suggested practices:

• Use references only if you really need to share variable content
• Pay attention to the cleaning work after using references in the loop, for example:

 foreach ($array as &$value) {
    // Do some operations}
unset($value); // Clear references to avoid side effects

3. The types are not rigorous (== vs ===)

PHP is a weak-type language that supports automatic type conversion, but when judging whether the variables are equal, if you use == instead of === , you may have a result that "looks shouldn't be equal".

For example:

 var_dump(0 == 'abc'); // true!
var_dump('123' == 123); // true

These results are often not in line with expectations, especially when judging the return value of the function and the database query results, it is easy to make mistakes.

Suggested practices:

• Use === to make congruent judgments, and compare values and types at the same time
• If you really need type conversion, you should also write it out clearly instead of relying on automatic conversion

4. Confused global variable usage (global and $GLOBALS)

Sometimes we need to access global variables inside the function, and then global or $GLOBALS will be used. But if the difference between them is not clear, it can lead to variable overlay or unpredictable behavior.

The difference between the two:

• global $var; is a reference to global variables
• $GLOBALS['var'] is a variable that accesses a hyperglobal array

Error example:

 $var = 10;
function test() {
    global $var;
    $var = 20;
}
test();
echo $var; // Output 20, modifying global variables

Suggested practices:

• Try to avoid frequent use of global variables, and use parameter transfer method to be clearer
• If necessary, encapsulation into class attributes or configuration items is preferred

Basically, these common PHP variables are wrong. After all, PHP's variable mechanism is flexible but not rigorous enough, and if you are not careful, you will fall into the pit. Developing good variable inspection and type judgment habits can reduce a lot of debugging time.

The above is the detailed content of Common PHP Variable Mistakes. For more information, please follow other related articles on the PHP Chinese website!