How to Check if an Array Is Empty in PHP

By the end of this page, you will understand how to check whether a value or an array is empty in PHP, when to check before using explode(), and which PHP functions are best for strings versus arrays.

In PHP, checking whether something is "empty" depends on what kind of data you have.

In this question, there are really two separate checks:

1. Is the players string empty before calling explode()?
2. Is the resulting array empty after calling explode()?

These are not the same thing.

Checking an empty string

If players comes from the database as an empty string like "", you can check it before splitting:

if ($gamerow['players'] === '') {
    // no players
}

This is often the best option if you want to skip unnecessary work.

Checking an empty array

If you already have an array, PHP provides simple ways to test whether it has any elements:

if (empty($playerlist)) {
    // array has no elements
}

or

 (() === ) {
    
}

Think of explode() like cutting a loaf of bread into slices.

• If you have a real loaf like "Alice,Bob,Charlie", cutting it at commas gives several pieces.
• If you have just one name like "Alice", cutting still gives one piece.
• If you have an empty string like "", PHP still hands you one "piece" containing nothing: [''].

So if you want to know whether there is any bread at all, check before slicing.

For arrays, imagine a box:

• an empty array is a box with nothing inside
• a non-empty array has at least one item inside
• [''] is still not an empty box; it contains one empty string

That difference is the key idea.

Core syntax

Check whether a string is empty

if ($gamerow['players'] === '') {
    echo 'No players';
}

Check whether an array is empty

if (empty($playerlist)) {
    echo 'Array is empty';
}

Check array length explicitly

if (count($playerlist) === 0) {
    echo 'Array is empty';
}

Example: check before explode()

$gamerow = mysql_fetch_array($gameresult);

if ($gamerow['players'] === '') {
    $playerlist = [];
} else {
    $playerlist = (, []);
}

Trace example

$players = '';

if (trim($players) === '') {
    $playerlist = [];
} else {
    $playerlist = explode(',', $players);
}

var_dump($playerlist);

What happens step by step

1. $players is assigned an empty string

$players = '';

At this point, there is no player data.

2. trim($players) is checked

if (trim($players) === '')

• trim('') is still ''
• the condition is true

3. An empty array is assigned

Common places this comes up

Database fields

A column may store:

• an empty string
• one value
• a comma-separated list

You often need to detect whether there is any real content before processing it.

Form input

A user may submit an optional field like:

Alice,Bob,Charlie

or leave it blank. Your code needs to handle both cases correctly.

Import scripts

CSV or text imports often contain blank values. Before splitting and processing them, you should check whether the source field is empty.

API data cleanup

An API might return a string of tags, roles, or IDs. If the field is blank, you may want an empty array instead of [''].

Filtering pipelines

Later code may loop over players, count them, or validate them. Starting with a proper empty array avoids bugs in those later steps.

How developers commonly handle this

Guard clause before processing

A guard clause stops work early if the data is missing.

$players = trim($gamerow['players']);

if ($players === '') {
    $playerlist = [];
    return;
}

$playerlist = array_map('trim', explode(',', $players));

This keeps the main logic clean.

Normalize data into a consistent shape

Real codebases often convert different inputs into one standard format.

$players = trim($gamerow['players']);
$playerlist = $players === '' ? [] : array_map('trim', explode(',', $players));

Now later code can always assume $playerlist is an array.

1. Assuming explode('', ...) gives an empty array

Broken expectation:

$playerlist = explode(',', '');
if (empty($playerlist)) {
    echo 'No players';
}

Why this is a problem:

• explode(',', '') returns ['']
• the array is not empty

Better:

$players = trim($gamerow['players']);
$playerlist = $players === '' ? [] : explode(',', $players);

2. Using empty() when 0 might be valid

$value = '0';
if (()) {
     ;
}

String check vs array check

empty() vs count()

Quick reference

Check if a string from the database is empty

if ($players === '')

Check if a string is empty or only spaces

if (trim($players) === '')

Check if an array is empty

if (empty($playerlist))

Check array length explicitly

if (count($playerlist) === 0)

Safe pattern for comma-separated values

$players = trim($gamerow['players']);
$playerlist = $players === '' ? [] : array_map('trim', explode(, ));

How do I check if an array is empty in PHP?

Use either of these:

empty($array)

or

count($array) === 0

Should I check before or after explode() in PHP?

Usually before. If the source string is empty, checking first lets you return [] instead of getting [''].

Does explode(',', '') return an empty array?

No. It returns an array containing one empty string:

['']

Is empty() safe for strings in PHP?

It is useful, but be careful: empty('0') is true. If '0' is a valid value, use === '' instead.

What is the best way to handle comma-separated values with spaces?

explode()

Splits a string into an array. It is directly related because the question involves turning comma-separated text into array items.

implode()

The opposite of explode(). It joins array items into a string.

empty()

A common PHP construct used to test whether a variable has an empty value.

count()

Used to count the number of elements in an array. Helpful when checking whether an array has zero items.

trim()

Removes leading and trailing whitespace. Useful before checking whether a string is really empty.

array_filter()

Removes unwanted values from an array, such as blank items created by extra commas.

PHP arrays

Understanding how arrays store values helps explain why [''] is not the same as [].

Input validation

Checking whether data is present and usable is part of validating user input or database values.