Problem

You want to provide an either-or branching condition assign a specific value to a variable in a single line of code.

Solution

Using a ternary operator (a ? b : c) allows nesting both an either-or condition and both possible branched values in a single statement. The following example shows how to define a variable with a value from the $GET superglobal and fall back on a default if it was empty.

$username = isset($_GET['username']) ? $_GET['username'] : 'default';

Discussion

A ternary expression has three arguments and is evaluated from left to right, checking the truthiness of the leftmost statement and returning the next value if true and the final value if false. You can visualize the logical flow here with the following illustration:

$value = (expression to evaluate) ? (if true) : (if false);

The ternary pattern is a simple way to return a default value when checking either system values or even parameters from a web request (i.e. those stored in the $_GET or $_POST superglobals). It is also a powerful way to switch logic in page templates based on the return of a particular function call.

The following example assumes a web application that welcomes logged in users by name (checking their authentication state with a call to is_logged_in()) or welcomes a guest if the user has yet to authenticate. As this example is coded directly into the HTML markup of a webpage, using a longer if/else statement would be inappropriate:

<h1>Welcome, <?php echo is_logged_in() ? $SESSION['username'] : 'Guest'; ?>!</h1>

Ternary operations can also be simplified if the value being checked is both truthy (i.e. evaluates to true when coerced into a Boolean value) and is the value you want by default. In the solution for this section, we both check that a username is set and assign that value to our variable if so. Since non-empty strings evaluate to true, we can shorten our solution to the following:

$username = $_GET['username'] ?: 'default';

When a ternary is shortened from its a ? b : c format to a simple a ?: c, PHP will evaluate the expression to check a as if it were a Boolean value. If it’s true, PHP merely returns the expression itself. If it’s false, then PHP returns the fallback value c instead.

The ternary operator is an advanced form of comparison operator that, while it provides for concise code, can sometimes be overused to create logic that is too difficult to follow. Consider the following example that nests one ternary operation within another.

$val = isset($_GET['username']) ? $_GET['username'] : isset($_GET['userid'])
       ? $_GET['user_id'] : null;

The preceding example should be rewritten as a simple if/else statement instead to provide more clarity as to how the code branches. There is nothing functionally wrong with the code, but nested ternaries can be difficult to read or reason about and often lead to logic errors down the road. The preceding ternary could be rewritten as follows:

if (isset($_GET['username'])) {
    $val = $_GET['username'];
} elseif (isset($_GET['userid'])) {
    $val = $_GET['userid'];
} else {
    $val = null;
}

While the rewritten example in Example 2-2 is much more verbose than Example 2-1, you can much more easily track where the logic needs to branch. It is also more maintainable in the long run as new branching logic can be added where necessary. Adding another logical branch to Example 2-1 would further complicate the already complex ternary and make the program even harder to maintain in the long run.

See Also

Documentation on the ternary operator and its variations.

Problem

You want to assign a specific value to a variable only if it’s set and not null and otherwise use a static default value.

Solution

Using a null-coalescing operator (??) as follows will use the first value only if it is set and non-null:

$username = $_GET['username'] ?? 'not logged in';

Discussion

PHP’s null coalescing operator is a newer feature introduced in PHP 7.0. It’s been referred to as syntactic sugar to replace the shorthand version of PHP’s ternary operator, ?:, which was discussed in Recipe 2.1.

Both of the following lines of code are functionally equivalent, but the ternary form will trigger an E_NOTICE if the expression being evaluated is undefined:

$a = $b ?: $c;
$a = $b ?? $c;

While the preceding two examples are functionally identical, there is a notable difference in their behavior if the value being evaluated ($b) is not defined. With the null coalescing operator, everything is golden. With the ternary shorthand, PHP will trigger a notice during execution that the value is undefined before returning the fallback value.

With discrete variables this isn’t entirely obvious - but when the evaluated component is, perhaps, an indexed array it’s more apparent how this could cause an impact. Assume that, instead if a discrete variable we are trying to extract an element from the superglobal $_GET variable that holds request parameters. In the following example, both the ternary and the null coalescing operators will return the fallback value, but the ternary version will complain about an undefined index:

$username = $_GET['username'] ?? 'anonymous';
$username = $_GET['username'] ?: 'anonymous'; // Notice: undefined index ...

If errors and notices are suppressed¹ during execution there is no functional difference between either operator option. It is, however, best practice to avoid writing code that triggers errors or notices, as these can accidentally alert in production or potentially fill system logs and make it more difficult to find legitimate issues with your code. While the short-hand ternary operator is remarkably useful, the null coalescing operator is purpose-built for this kind of operation and should nearly always be used instead.

See Also

The announcement of the new operator when it was first added to PHP 7.0.

Problem

You want to compare two values of the same type to ensure they’re identical.

Solution

Use three equal signs to compare values without dynamically casting their types as follows:

if ($a === $b) {
    // ...
}

Discussion

In PHP, the equal sign has three different functions. A single equal sign (=) is used for assignment, which is setting the value of a variable. Two equal signs (==) are used in an expression to determine whether the values on either side are equal. Table 2-4 presents an illustration of how certain values are considered equal due to how PHP coerces one type into another while evaluating the statement. Finally, three equal signs (===) are used in an expression to determine whether the values on either side are identical.

PHP’s ability to dynamically convert between types at runtime can be useful, but in some cases it is not what we want to have happen at all. The Boolean literal false is returned by some methods to represent an error or failure, while an integer 0 might be a valid return of a function. Consider the following function that returns a count of books of a specific category, or false if a connection to the database holding that data fails:

function count_books_of_type($category)
{
    $sql = "SELECT COUNT(*) FROM books WHERE category = :category";

    try {
        $dbh = new PDO(DB_CONNECTION_STRING, DB_LOGIN, DB_PASS);
        $statement = $dbh->prepare($sql);

        $statement->execute(array(':category' => $category));
        return $sth->fetchColumn();
    } catch(PDOException $e) {
        return false;
    }
}

In the preceding example, the function will return false if there are any errors in creating the database connection or querying for data. If everything runs as expected, it will then return an integer count of the number of books in a particular category. The following code might leverage this function to print a headline on a webpage:

$books_found = count_books_of_type('fiction');

switch($books_found) {
    case 0:
        echo 'No fiction books found';
        break;
    case 1:
        echo 'Found one fiction book';
        break;
    default:
        echo 'Found ' . $books_found . ' fiction books';
}

Internally, PHP’s switch statement is using a loose type comparison (our == operator). If count_books_of_type() returns false instead of an actual result, this switch statement will print out that no fiction books were found rather than reporting an error. In this particular use case, that might be acceptable behavior - but when your application needs to reflect a material difference between false and 0, loose equality comparisons are inadequate.

Instead, PHP permits the use of three equal signs (===) to check whether both values under evaluation are identical. That is, they are both the same value and the same type. Even though the integer 5 and the string "5" have the same value, evaluating 5 === "5" will result in “false” because the two values are not the same type. Thus, while 0 == false evaluates to true, 0 === false will always evaluate to false.

See Also

PHP documentation on comparison operators.

Problem

You want to provide a custom ordering function to sort an arbitrary list of objects using PHP’s native usort().

Solution

Assuming you want to sort by multiple properties of the list of objects, use PHP’s spaceship operator (<=>) to define a custom sorting function and supply that as the callback to usort().

Consider the following class definition for a person in your application that allows creating records with just first and last names:

class Person {
    public $firstName;
    public $lastName;

    public function __construct($first, $last)
    {
        $this->firstName = $first;
        $this->lastName = $last;
    }
};

You can then create a list of people, perhaps US presidents, using this class and adding each person to your list in turn as follows:

$presidents = [];

$presidents[] = new Person('George', 'Washington');
$presidents[] = new Person('John', 'Adams');
$presidents[] = new Person('Thomas', 'Jefferson');
// ...
$presidents[] = new Person('Barack', 'Obama');
$presidents[] = new Person('Donald', 'Trump');
$presidents[] = new Person('Joseph', 'Biden');

The spaceship operator can then be leveraged to identify how to sort this data, assuming we want to order by last name first, then by first name as follows:

function presidential_sorter($left, $right)
{
    return [$left->lastName, $left->firstName] <=> [$right->lastName, $right->firstName];
}

usort($presidents, 'presidential_sorter');

The result of the preceding call to usort() is that our $presidents array will be properly sorted in place and ready for use.

Discussion

The spaceship operator is a special addition as of PHP 7.0 that helps identify the relationship between the values on either side of it:

• If the first value is less than the second, the expression evaluates to -1

• If the first value is greater than the second, the expression evaluates to +1

• If both values are the same, the expression evaluates to 0

The simplest use of the spaceship operator compares simple types with one another, making it easy to order a simple array or list of primitive values (like characters, integers, floating point numbers, or dates). This simple case, if using usort(), would require a sorting function like the following:

function sorter($a, $b) {
    return ($a < $b) ? -1 : (($a > $b) ? 1 : 0);
}

The spaceship operator simplifies the nested ternary in the preceding code by replacing the return statement entirely with return $a <=> $b, but without modifying the functionality of the sorting function at all.

More complex examples, like that used in our solution to sort based on multiple properties of a custom object definition, would necessitate rather verbose sorting function definitions. The spaceship operator simplifies comparison logic, empowering developers to specify otherwise complex logic in a single, easy-to-read line.

See Also

The original RFC for PHP’s spaceship operator.

Problem

You want to explicitly ignore or suppress errors triggered by a specific expression in your application.

Solution

Prefix the expression with the @ operator to temporarily set the error reporting level to 0 for that line of code. This might help suppress errors related to missing files when attempting to open them directly as in the following example:

$fp = @fopen('file_that_des_not_exist.txt', 'r');

Discussion

In the example code provided in our solution, we attempt to open the file file_that_does_not_exist.txt for reading. In normal operations, a call to fopen() would return false as the file does not exist and emit a PHP warning for the purposes of diagnosing the issue. Prefixing our expression with the @ operator doesn’t change the return value at all, but it suppresses the emitted warning entirely.

The use of this particular operator is useful when suppressing errors or warnings on file access operations (like in the solution example). It’s also useful in suppressing notices in array access operations as in the following where a specific GET parameter might not be set in a request:

$filename = @$_GET['filename'];

In the preceding example, the $filename variable will be set to the value of the request’s filename query parameter if it’s set. Otherwise, it will be a literal null. If a developer were to omit the @ operator, the value of $filename will still be null, but PHP will emit a notice that the index of filename does not exist in the array.

As of PHP 8.0, this operator will no longer suppress fatal errors in PHP that otherwise halt script execution.

See Also

Official PHP documentation on error control operators.

Problem

You want to use simple flags to identify state and behavior in your application where one member might have multiple flags applied.

Solution

Use a bitmask to specify which flags are available and bitwise operators on the subsequent flags to identify which are set. The following example defines four discrete flags using a binary notation of the integer each represents and combines them together to indicate multiple flags being set at once. PHP’s bitwise operators are then used to identify which flag is set and which branch of conditional logic should be executed.

const FLAG_A = 0b0001; // 1
const FLAG_B = 0b0010; // 2
const FLAG_C = 0b0100; // 4
const FLAG_D = 0b1000; // 8

// Set a composite flag for an application
$application = FLAG_A | FLAG_B; // 0b0011 or 5

// Set a composite flag for a user
$user = FLAG_B | FLAG_C | FLAG_D; // 0b1110 or 14

// Switch based on the user's applied flags
if ($user & FLAG_B) {
    // ...
} else {
    // ...
}

Discussion

A bitmask is structured by configuring each flag to be a constant integer power of 2. This has the benefit of only setting a single bit in the binary representation of the number such that composite flags are then identified by which bits are set. In the code block in our solution, each flag is written explicitly as a binary number to illustrate which bits are set (1) versus unset (0) with the integer representation of the same number in a comment at the end of the line.

Our example’s FLAG_B is the integer 2, which is represented in binary as 0010 (the third bit is set). Likewise, FLAG_C is the integer 4 with a binary representation of 0100 (the second bit is set). To specify that both flags are set, we add the two together to set both the second and third bits: 0110 or the integer 6.

For this specific example, addition is an easy model to keep in mind, but it’s not exactly what is going on. To combine flags we merely want to combine the bits that are set, not necessarily add them together. Combining FLAG_A with itself should result in only FLAG_A - adding the integer representation (1) to itself would change the meaning of our flag entirely.

Rather than addition, we use the bitwise operations “or” (|) and “and” (&) to both combine bits and filter on assigned flags. Combining two flags together requires using the | operator to create a new integer with bits set that are set in either of the flags being used. Consider the following example to create a composite of FLAG_A | FLAG_C:

Comparing composite flags against our definitions then requires the & operator, which returns a new number that has bits that are set that are set in both sides of the operation. Comparing a flag to itself will always return 0, which is type cast to false in conditional checks. Comparing two values that have any of the same bits set will return a value greater than 0, which is type cast to true. Consider the simple case where we evaluate FLAG_A & FLAG_C in the following table:

Instead of comparing primitive flags against one another, we can and should build composite values and then compare them to our sets of flags. In the following example we visualize the role-based access control system of a content management system for publishing news articles. Users can view articles, create articles, edit articles, or delete articles - their level of access is determined by the program itself and the permissions that are granted to their user account.

const VIEW_ARTICLES   = 0b0001;
const CREATE_ARTICLES = 0b0010;
const EDIT_ARTICLES   = 0b0100;
const DELETE_ARTICLES = 0b1000;

A typical, anonymous visitor will never be logged in and will then be granted a default permission of being able to view content. Logged in users might be able to create articles but not edit things without an editor’s permission. Likewise, editors can review and modify content (or delete it) but cannot independently create anything. Finally, administrators might be allowed to do everything. Each of the roles is composited from the preceding permission primitives as follows:

const ROLE_ANONYMOUS = VIEW_ARTICLES;
const ROLE_AUTHOR    = VIEW_ARTICLES | CREATE_ARTICLES;
const ROLE_EDITOR    = VIEW_ARTICLES | EDIT_ARTICLES | DELETE_ARTICLES;
const ROLE_ADMIN     = VIEW_ARTICLES | CREATE_ARTICLES | EDIT_ARTICLES
                       | DELETE_ARTICLES;

Once our composite roles are defined from primitive permissions, the application can structure logic around checking the user’s active role. We composited permissions together with the | operator, but the & operator will allow us to switch based on these flags as follows:

function get_article($article_id)
{
    $role = get_user_role();

    if ($role & VIEW_ARTICLES) {
        // ...
    } else {
        throw new UnauthorizedException();
    }
}

function create_article($content)
{
    $role = get_user_role();

    if ($role & CREATE_ARTICLES) {
        // ...
    } else {
        throw new UnauthorizedException();
    }
}

function edit_article($article_id, $content)
{
    $role = get_user_role();

    if ($role & EDIT_ARTICLES) {
        // ...
    } else {
        throw new UnauthorizedException();
    }
}

function delete_article($article_id)
{
    $role = get_user_role();

    if ($role & DELETE_ARTICLES) {
        // ...
    } else {
        throw new UnauthorizedException();
    }
}

Bitmasks are a powerful way to implement simple flags in any language. Take caution, though, if the number of flags needed is ever planned to go - each new flag represents an additional power of 2, meaning things grow rapidly in size. However, they’re commonly used in both PHP applications and by the language itself. PHP’s own error reporting setting, discussed further in Chapter 12, leverages bitwise values to identify the level of error reporting used by the engine itself.

See Also

PHP documentation on bitwise operators.