PHP empty(): verificar strings, arrays vazios e 0

empty($var) retorna true se a variável não existe ou se o valor dela é falso: null, false, 0, 0.0, "", "0" ou um array vazio []. Para qualquer outro valor, retorna false. Como o isset(), ele nunca avisa sobre variáveis ou chaves de array indefinidas.

<?php
$name = "";
$items = [];
$count = 0;
$city = "Paris";

var_dump(empty($name));
var_dump(empty($items));
var_dump(empty($count));
var_dump(empty($city));
var_dump(empty($notDefined));

if (empty($items)) {
    echo "Your cart is empty\n";
}

empty($x) é o mesmo que !isset($x) || !$x. Em outras palavras: ausente, ou vira false.

Quais valores são vazios

Escolha um valor na tabela para ver empty() ao lado de isset() e do cast (bool). Cada célula foi calculada pelo PHP 8.3.

As surpresas estão nas duas pontas: "0" é vazio, enquanto " " (um espaço), "0.0", "null" e [0] não são.

"0" é vazio: o bug clássico

Como "0" é falso, o empty() trata uma quantidade 0, uma pontuação 0 ou um PIN "0" como "nada digitado". Isso pega em formulários, onde todo valor chega como string.

<?php
$submitted = ["quantity" => "0", "comment" => "", "pin" => "0"];

foreach ($submitted as $field => $value) {
    $byEmpty = empty($value) ? "missing" : "ok";
    $byString = trim($value) === "" ? "missing" : "ok";
    printf("%-9s %-4s empty(): %-8s trim() === '': %s\n",
        $field, var_export($value, true), $byEmpty, $byString);
}

Para entrada de texto, a verificação confiável de "nada digitado" é trim($value) === "". Deixe o empty() para valores em que 0 realmente significa nada.

Verificar se uma string está vazia

Para testar uma string vazia com exatidão, compare com "". Para também tratar espaços em branco como vazio, aplique trim antes. Desde o PHP 5.5, o empty() aceita expressões, então empty(trim($s)) também funciona (mas tem o mesmo problema do "0").

<?php
$tests = ["", "   ", "0", "hello", null];

foreach ($tests as $s) {
    printf("%-8s === '': %-5s  trim === '': %-5s  empty(): %s\n",
        var_export($s, true),
        var_export($s === "", true),
        var_export(trim($s ?? "") === "", true),
        var_export(empty($s), true));
}

trim() não aceita null sem um aviso de depreciação no PHP 8.1 e posteriores, e é por isso que o bloco escreve trim($s ?? "").

Verificar se um array está vazio

Para arrays, empty($arr), $arr === [] e count($arr) === 0 dão a mesma resposta. O empty() tem a vantagem de funcionar numa variável ou chave que talvez não exista.

<?php
$cart = [];
$tags = ["php"];
$order = ["lines" => []];

var_dump(empty($cart), $cart === [], count($cart) === 0);
var_dump(empty($tags));
var_dump(empty($order["lines"]));
var_dump(empty($order["discounts"]));   // key not there at all

// An array of empty values is not empty
var_dump(empty(["", null, 0]));

// To ignore blank entries, filter first
var_dump(empty(array_filter(["", null, 0])));

array_filter() sem callback remove todos os valores falsos, então é um jeito rápido de perguntar "este array tem algo de verdade".

Validar um campo obrigatório do formulário

!empty() é um jeito comum de exigir um campo, desde que 0 não seja uma resposta válida. Rode este bloco, deixe os campos em branco e clique em Send, depois preencha e envie de novo: o script roda mais uma vez com $_POST preenchido.

<?php
$errors = [];
$sent = ($_SERVER["REQUEST_METHOD"] ?? "GET") === "POST";

if ($sent) {
    if (empty($_POST["email"])) {
        $errors[] = "Email is required.";
    }
    if (empty($_POST["terms"])) {
        $errors[] = "Please accept the terms.";
    }
    // Age 0 is invalid anyway, but "" must be caught: here empty() fits
    if (empty($_POST["age"]) || !ctype_digit($_POST["age"])) {
        $errors[] = "Age must be a whole number.";
    }
}
?>
<form method="post">
  <p><label>Email <input name="email" value="<?= htmlspecialchars($_POST["email"] ?? "") ?>"></label></p>
  <p><label>Age <input name="age" value="<?= htmlspecialchars($_POST["age"] ?? "") ?>"></label></p>
  <p><label><input type="checkbox" name="terms" value="1" <?= empty($_POST["terms"]) ? "" : "checked" ?>> I accept the terms</label></p>
  <button>Send</button>
</form>
<?php if ($sent && !$errors): ?>
  <p style="color:#0a7">Thanks, all fields are valid.</p>
<?php endif; ?>
<?php foreach ($errors as $e): ?>
  <p style="color:#c33"><?= $e ?></p>
<?php endforeach; ?>

empty($_POST["terms"]) cobre os dois casos do checkbox: não enviado, ou enviado com valor vazio. A página sobre formulários vai além, com mensagens de erro por campo.

empty ou isset

Os dois são seguros com variáveis e chaves indefinidas. Eles respondem perguntas diferentes:

<?php
$values = ["null" => null, "zero" => 0, "zero string" => "0", "empty string" => "", "space" => " ", "text" => "php"];

printf("%-13s %-7s %-7s %s\n", "", "isset", "empty", "!empty");
foreach ($values as $label => $v) {
    printf("%-13s %-7s %-7s %s\n", $label,
        var_export(isset($v), true),
        var_export(empty($v), true),
        var_export(!empty($v), true));
}

• isset($x): existe e não é null? Use para chaves opcionais, checkboxes e "isto foi enviado".
• !empty($x): existe e é verdadeiro? Use para "tem algo de verdade", quando 0 e "0" não contam.
• $x === "" ou $x === []: está exatamente vazio? Use quando 0 é um valor válido.

A página sobre isset cobre a outra metade, incluindo isset() com várias variáveis de uma vez e a diferença para array_key_exists().