Introduction
In PHP, NULL is a special data type representing a variable with no value; understanding its implications is key to writing robust applications. This tutorial illustrates its use through gradually complex examples.
The Basics of NULL
When a variable is created without a value, it is automatically assigned NULL. In PHP, NULL is case-insensitive, meaning null, NULL, or Null are equivalent. Let’s see this in action:
$var; // Declares a variable without initializing
var_dump($var); // Outputs NULL
We can also explicitly assign NULL to a variable:
$var = NULL;
var_dump($var); // Outputs NULL
To check if a variable is NULL, use the is_null() function:
$var = NULL;
var_dump(is_null($var)); // Outputs bool(true)
NULL and Unset Variables
Unsetting a variable using unset() also results in NULL when it is later accessed:
$var = 'PHP';
unset($var);
var_dump($var); // Outputs NULL
Remember, an unset variable and an uninitialized variable are effectively the same in terms of their value – both contain NULL.
NULL in Comparisons
The comparison with NULL is another area where understanding its behavior is crucial. Let’s explore the == and === operators:
$var = NULL;
var_dump($var == NULL); // Outputs bool(true)
var_dump($var === NULL); // Outputs bool(true)
$var = 0;
var_dump($var == NULL); // Outputs bool(true): 0 is 'equal' to NULL
var_dump($var === NULL); // Outputs bool(false): 0 is not identical to NULL
When using ==, NULL is considered equal to zero and an empty string. However, with ===, they are not identical as they are not of the same type.
NULL in Functions
In functions, variables can be returned as NULL explicitly or implicitly if no value is returned. Let’s compare:
function returnNothing() {}
var_dump(returnNothing()); // Implicitly returns NULL
function returnNull() { return NULL; }
var_dump(returnNull()); // Explicitly returns NULL
Using NULL as a default parameter value is also commendable:
function say($word = NULL) {
if(is_null($word)) {
echo 'No word to say.';
} else {
echo $word;
}
}
say(); // Echoes 'No word to say.'
say('PHP!'); // Echoes 'PHP!'
NULL Coalescing Operator
The null coalescing operator, introduced in PHP 7, provides a neat way to use a default value when dealing with NULL. It is represented by ??:
$username = $_GET['user'] ?? 'guest';
echo $username; // Outputs 'guest' if $_GET['user'] is not set
This operator can also be chained for multiple checks:
$username = $_POST['user'] ?? $_GET['user'] ?? 'guest';
echo $username;
Handling NULL with the spaceship operator
PHP 7 introduced the spaceship operator <> which can also handle NULL comparisons. It returns 0 if both sides are equal, 1 if the left side is greater, or -1 if the right side is greater:
$a = NULL;
$b = 0;
echo $a <=> $b; // Outputs -1
The result here indicates that, in terms of ordering, NULL is considered to be less than 0.
Dealing with Databases
In SQL databases, NULL represents a missing or inapplicable value. It’s important to use the isset() function to check whether a database query returns NULL or an actual result:
// Assume $db is a database connection and the query might return a NULL value
$result = $db->query('SELECT ...');
if(isset($result)) {
// Handle result
} else {
// Handle NULL
}
Best Practices and Pitfalls
It is important to distinguish between NULL and false, undefined, or empty strings. Using type-specific checks, like is_null() or the triple equals operator ===, is generally more reliable than loose comparisons.
Furthermore, consider if NULL is the most semantical value to use. Sometimes a default value or even an empty object may convey clearer intent. Always sanitize and validate user input, as relying on NULL to represent the absence of data could introduce security vulnerabilities or bugs.
Conclusion
This tutorial has provided a comprehensive walkthrough about NULL in PHP. From simple variable initialization to advanced usage with null coalescing and the spaceship operator, understanding NULL allows you to write more concise and robust PHP code. Embrace NULL, but always use it conscientiously and consistently to avoid unintended consequences.
