¿Por qué verificar isset () y! Empty ()

¿Hay alguna diferencia entre issety !empty. Si hago esta doble verificación booleana, ¿es correcta de esta manera o redundante? y hay una forma más corta de hacer lo mismo?

isset($vars[1]) AND !empty($vars[1])

Esto es completamente redundante. emptyes más o menos abreviatura para !isset($foo) || !$foo, y !emptyes análogo a isset($foo) && $foo. Es decir, emptyhace lo contrario de issetmás una verificación adicional de la veracidad de un valor.

O en otras palabras, emptyes lo mismo que !$foo, pero no arroja advertencias si la variable no existe. Ese es el punto principal de esta función: hacer una comparación booleana sin preocuparse por la variable que se está configurando.

El manual lo pone así:

empty()es lo opuesto a (boolean) var, excepto que no se genera ninguna advertencia cuando la variable no está establecida.

Simplemente puede usar !empty($vars[1])aquí.

isset() prueba si una variable está establecida y no es nula:

http://us.php.net/manual/en/function.isset.php

empty() puede devolver verdadero cuando la variable se establece en ciertos valores:

http://us.php.net/manual/en/function.empty.php

Para demostrar esto, intente el siguiente código con $ the_var sin asignar, establecido en 0 y establecido en 1.

<?php

#$the_var = 0;

if (isset($the_var)) {
  echo "set";
} else {
  echo "not set";
}

echo "\n";

if (empty($the_var)) {
  echo "empty";
} else {
  echo "not empty";
}
?>

La respuesta aceptada no es correcta.

isset () NO es equivalente a! empty ().

Creará algunos errores bastante desagradables y difíciles de depurar si sigue esta ruta. Por ejemplo, intente ejecutar este código:

<?php

$s = '';

print "isset: '" . isset($s) . "'. ";
print "!empty: '" . !empty($s) . "'";

?>

https://3v4l.org/J4nBb

$a = 0;
if (isset($a)) { //$a is set because it has some value ,eg:0
    echo '$a has value';
}
if (!empty($a)) { //$a is empty because it has value 0
    echo '$a is not empty';
} else {
    echo '$a is empty';
}

Empty just check es la variable / matriz referida que tiene un valor si verifica el php doc (vacío) verá que estas cosas se consideran vacías

* "" (an empty string)
* 0 (0 as an integer)
* "0" (0 as a string)
* NULL
* FALSE
* array() (an empty array)
* var $var; (a variable declared, but without a value in a class)

while isset comprueba si la variable isset y no es nula, que también se puede encontrar en el php doc (isset)

No es necesario.

No se genera ninguna advertencia si la variable no existe. Eso significa que empty () es esencialmente el conciso equivalente a! Isset ($ var) || $ var == falso.

php.net

isset($vars[1]) AND !empty($vars[1])es equivalente a !empty($vars[1]).

Preparé un código simple para mostrarlo empíricamente.

La última fila es una variable indefinida.

+-----------+---------+---------+----------+---------------------+
| Var value | empty() | isset() | !empty() | isset() && !empty() |
+-----------+---------+---------+----------+---------------------+
| ''        | true    | true    | false    | false               |
| ' '       | false   | true    | true     | true                |
| false     | true    | true    | false    | false               |
| true      | false   | true    | true     | true                |
| array ()  | true    | true    | false    | false               |
| NULL      | true    | false   | false    | false               |
| '0'       | true    | true    | false    | false               |
| 0         | true    | true    | false    | false               |
| 0.0       | true    | true    | false    | false               |
| undefined | true    | false   | false    | false               |
+-----------+---------+---------+----------+---------------------+

Y código

$var1 = "";
$var2 = " ";
$var3 = FALSE;
$var4 = TRUE;
$var5 = array();
$var6 = null;
$var7 = "0";
$var8 = 0;
$var9 = 0.0;

function compare($var)
{
    print(var_export($var, true) . "|" .
        var_export(empty($var), true) . "|" .
        var_export(isset($var), true) . "|" .
        var_export(!empty($var), true) . "|" .
        var_export(isset($var) && !empty($var), true) . "\n");
}

for ($i = 1; $i <= 9; $i++) {
    $var = 'var' . $i;
    compare($$var);
}

@print(var_export($var10, true) . "|" .
    var_export(empty($var10), true) . "|" .
    var_export(isset($var10), true) . "|" .
    var_export(!empty($var10), true) . "|" .
    var_export(isset($var10) && !empty($var10), true) . "\n");

La variable no definida debe evaluarse fuera de la función, porque la función en sí misma crea una variable temporal en el ámbito mismo.

"Vacío": solo funciona en variables. Vacío puede significar diferentes cosas para diferentes tipos de variables (consulte el manual: http://php.net/manual/en/function.empty.php ).

"isset": comprueba si la variable existe y busca un valor NULL verdadero o falso. Puede desarmarse llamando a "desarmado". Una vez más, consulte el manual.

El uso de cualquiera de los dos depende del tipo de variable que esté utilizando.

Yo diría que es más seguro verificar ambos, porque primero está verificando si la variable existe y si realmente no es NULL o está vacía.

si usamos la misma página para agregar / editar a través del botón Enviar como se muestra a continuación

<input type="hidden" value="<?echo $_GET['edit_id'];?>" name="edit_id">

entonces no debemos usar

isset($_POST['edit_id'])

bcoz edit_idse establece todo el tiempo, ya sea agregar o editar página, en su lugar, deberíamos usar la verificación debajo de la condición

!empty($_POST['edit_id'])

• Desde el sitio web de PHP, refiriéndose a la empty()función:

Devuelve FALSEsi vartiene un valor no vacío y no cero.

Eso es bueno saberlo. En otras palabras, todo, desde NULL, 0hasta "" volverá TRUEal usar la empty()función.

• Aquí está la descripción de lo isset()que devuelve la función:

Devuelve TRUEsi varexiste; FALSEde otra manera.

En otras palabras, solo las variables que no existen (o variables con NULLvalores estrictos ) volverán FALSEa la isset()función. Todas las variables que tienen cualquier tipo de valor, si se trata de 0una cadena de texto en blanco, etc. volverán TRUE.