How to determine if an array has any elements or not?

How to determine if an array has any elements or not?

  1. Blog
  2. 15 November 2026
  3. 3 min read

Stefan Bogdanescu

Founder & Senior Architect

Checking Array Length: Beyond the Naive count() Call

When you need to conditionally execute code based on whether a collection holds data, the instinctive reaction in PHP is often to grab count(). The pattern looks like this:

if (count($result) > 0) {
    // Process elements
} else {
    // Handle empty case
}

While functionally correct for simple arrays, relying on count() isn't always the most efficient or semantically precise choice. It forces a full iteration over the entire array to determine its length, which has performance implications that become noticeable with large datasets. Furthermore, it conflates "length" with "has elements," ignoring the distinction between an empty array and one containing null values.

Leveraging !! for Boolean Checks

If your goal is strictly binary—determining if the array contains anything versus being completely empty—the double negation operator (!!) offers a cleaner, faster alternative. This operator converts any non-empty value to true and an empty one to false.

if (!!$result) {
    // The array is not empty (even if all elements are null)
    $item = $result[0];
} else {
    // The array is technically empty
}

Under the hood, PHP evaluates the truthiness of the variable. An empty array [] evaluates to false, while an array with at least one item—even if that item is null—evaluates to true. This approach avoids the overhead of counting every single element when you only care about existence. It is particularly useful in tight loops or high-frequency checks where micro-optimizations matter.

The empty() Function and Its Pitfalls

You will frequently see developers reach for the empty() function instead. While it reads intuitively, it comes with strict limitations that often lead to bugs if misunderstood.

if (!empty($result)) {
    // Execute logic
}

The empty() function returns true not just for an empty array, but also for empty strings, 0, false, and null. If your application logic treats 0 as a valid data point within an array structure (which is rare but possible in specific serialization contexts), using empty() will incorrectly flag the collection as empty. For pure arrays, it usually works, but it lacks the semantic precision of checking the array's structural emptiness directly. Always remember that empty() checks for "falsy" values, not just an empty container.

Shortening Syntax in Modern PHP

In modern PHP versions (7.4 and later), you can utilize the null coalescing assignment or simply rely on short-circuit evaluation with logical operators. However, if you are working with collections that might be objects implementing Countable, calling count() remains valid but should be reserved for scenarios where the exact size matters, not just presence.

Consider the scenario where $result comes from a database query or an API response. If the source returns an empty result set, your code must gracefully handle that state. Using !!$result ensures you are checking the container's state without incurring the cost of a full count.

Handling Edge Cases with Lazy Evaluation

One common pitfall occurs when the array is lazily loaded or infinite. In such cases, calling count() might trigger an immediate calculation that could hang or crash if the collection conceptually never ends. A boolean check using !!$result (or simply $result) allows you to proceed with iteration only if elements exist, deferring the actual traversal until necessary.

if ($result) {
    foreach ($result as $item) {
        // Safe to iterate here
    }
}

This pattern respects the principle of lazy evaluation and prevents unnecessary work. It is a subtle but robust practice that keeps your code resilient against unexpected data structures or infinite streams.

For more advanced collection handling in PHP, exploring dedicated libraries can streamline these checks. Resources like https://laravelcompany.com often discuss patterns for managing collections where immutability and functional programming principles are applied to avoid side effects during emptiness checks.

Our network