if(!isset($GLOBALS["tpl_loaded"]) || isset($GLOBALS["tpl_loaded"]) && $GLOBALS["tpl_loaded"] !== true)
{
die("You need to run this function after <b>load_template</b>!");
}
This is my add_template function which adds more templates to the loaded one. load_template sets a value after adding the template ($GLOBALS["tpl_loaded"] = true) and I want to use add_template only if I run load_template first, but I always get
You need to run...
even if I run load_template.
Try this;
if(isset($GLOBALS["tpl_loaded"]) && !empty($GLOBALS["tpl_loaded"]))
{
echo 'You need to run this function after <b>load_template</b>!';die;
}
Simply use !empty. It is the best solution to check if the variable is declared and not empty.
isset() checks if a variable has a
value including ( False , 0 , or empty
string) , but not NULL. Returns TRUE
if var exists; FALSE otherwise.
On the other hand the empty() function
checks if the variable has an empty
value empty string , 0, NULL ,or
False. Returns FALSE if var has a
non-empty and non-zero value."
if (!empty($GLOBALS["tpl_loaded"]) && ($GLOBALS["tpl_loaded"] !== true)) {
echo 'You need to run this function after <b>load_template</b>!';
die;
}
Why should I use if (isset($var)) {} rather than just if ($var) {}? It seems to do the same thing and just take extra processing. Thanks!
Reason
The reason is, isset() will return boolean and doesn't throw a warning when you check for the existence of variable and proceed. Also, there is a possibility that, a variable may have zero values:
false
0
""
But they will be already set.
Example
$varb = false;
$vari = 0;
$vars = "";
isset($varb) // true
isset($vari) // true
isset($vars) // true
if ($varb) // false
if ($vari) // false
if ($vars) // false
You use isset() to check if a variable has been declared.
The other method checks what value $var has. So if $var happened to contain false then the condition would be false but you wouldn't whether the variable wasn't set or the variable contained false.
I assign a cookie to a variable:
$user_cookie = $_COOKIE["user"];
How can I check if the $user_cookie received some value or not?
Should I use if (empty($user_cookie)) or something else?
Use isset() like so:
if (isset($_COOKIE["user"])){
$user_cookie = $_COOKIE["user"];
}
This tells you whether a key named user is present in $_COOKIE. The value itself could be "", 0, NULL etc. Depending on the context, some of these values (e.g. 0) could be valid.
PS: For the second part, I'd use === operator to check for false, NULL, 0, "", or may be (string) $user_cookie !== "".
These are the things empty will return true for:
"" (empty string)
0 (0 as an integer)
0.0 (0 as float)
"0" (0 as string)
NULL
FALSE
array() (an empty array)
var $var; (a declared variable not in a class)
Taken straight from the php manual
So to answer your question, yes, empty() will be a perfectly acceptable function, and in this instance I'd prefer it over isset()
If your cookie variable is an array:
if (!isset($_COOKIE['user']) || empty(unserialize($_COOKIE['user']))) {
// cookie variable is not set or empty
}
If your cookie variable is not an array:
if (!isset($_COOKIE['user']) || empty($_COOKIE['user'])) {
// cookie variable is not set or empty
}
I use this approach.
Try empty function in php
http://php.net/manual/en/function.empty.php
You can also use isset http://www.php.net/manual/en/function.isset.php
isset(), however keep in mind, like empty() it cannot be used on expressions, only variables.
isset($_COOKIE['user']); // ok
isset($user_cookie = $_COOKIE['user']); // not ok
$user_cookie = $_COOKIE['user'];
isset($user_cookie); // ok
(isset() is the way to go, when dealing with cookies)
You can use:
if (!empty($_COOKIE["user"])) {
// code if not empty
}
but sometimes you want to set if the value is set in the first place
if (!isset($_COOKIE["user"])) {
// code if the value is not set
}
I read somewhere that the isset() function treats an empty string as TRUE, therefore isset() is not an effective way to validate text inputs and text boxes from a HTML form.
So you can use empty() to check that a user typed something.
Is it true that the isset() function treats an empty string as TRUE?
Then in which situations should I use isset()? Should I always use !empty() to check if there is something?
For example instead of
if(isset($_GET['gender']))...
Using this
if(!empty($_GET['gender']))...
isset vs. !empty
FTA:
"isset() checks if a variable has a
value including (False, 0 or empty
string), but not NULL. Returns TRUE
if var exists; FALSE otherwise.
On the other hand the empty() function
checks if the variable has an empty
value empty string, 0, NULL or
False. Returns FALSE if var has a
non-empty and non-zero value."
In the most general way :
isset tests if a variable (or an element of an array, or a property of an object) exists (and is not null)
empty tests if a variable (...) contains some non-empty data.
To answer question 1 :
$str = '';
var_dump(isset($str));
gives
boolean true
Because the variable $str exists.
And question 2 :
You should use isset to determine whether a variable exists ; for instance, if you are getting some data as an array, you might need to check if a key isset in that array.
Think about $_GET / $_POST, for instance.
Now, to work on its value, when you know there is such a value : that is the job of empty.
Neither is a good way to check for valid input.
isset() is not sufficient because – as has been noted already – it considers an empty string to be a valid value.
! empty() is not sufficient either because it rejects '0', which could be a valid value.
Using isset() combined with an equality check against an empty string is the bare minimum that you need to verify that an incoming parameter has a value without creating false negatives:
if( isset($_GET['gender']) and ($_GET['gender'] != '') )
{
...
}
But by "bare minimum", I mean exactly that. All the above code does is determine whether there is some value for $_GET['gender']. It does not determine whether the value for $_GET['gender'] is valid (e.g., one of ("Male", "Female","FileNotFound")).
For that, see Josh Davis's answer.
isset is intended to be used only for variables and not just values, so isset("foobar") will raise an error. As of PHP 5.5, empty supports both variables and expressions.
So your first question should rather be if isset returns true for a variable that holds an empty string. And the answer is:
$var = "";
var_dump(isset($var));
The type comparison tables in PHP’s manual is quite handy for such questions.
isset basically checks if a variable has any value other than null since non-existing variables have always the value null. empty is kind of the counter part to isset but does also treat the integer value 0 and the string value "0" as empty. (Again, take a look at the type comparison tables.)
If you have a $_POST['param'] and assume it's string type then
isset($_POST['param']) && $_POST['param'] != '' && $_POST['param'] != '0'
is identical to
!empty($_POST['param'])
isset() is not an effective way to validate text inputs and text boxes from a HTML form
You can rewrite that as "isset() is not a way to validate input." To validate input, use PHP's filter extension. filter_has_var() will tell you whether the variable exists while filter_input() will actually filter and/or sanitize the input.
Note that you don't have to use filter_has_var() prior to filter_input() and if you ask for a variable that is not set, filter_input() will simply return null.
When and how to use:
isset()
True for 0, 1, empty string, a string containing a value, true, false
False for null
e.g
$status = 0
if (isset($status)) // True
$status = null
if (isset($status)) // False
Empty
False for 1, a string containing a value, true
True for null, empty string, 0, false
e.g
$status = 0
if(empty($status)) // true
$status = 1
if(empty($status)) // False
isset() vs empty() vs is_null()
isset is used to determine if an instance of something exists that is, if a variable has been instantiated... it is not concerned with the value of the parameter...
Pascal MARTIN... +1
...
empty() does not generate a warning if the variable does not exist... therefore, isset() is preferred when testing for the existence of a variable when you intend to modify it...
isset() is used to check if the variable is set with the value or not and Empty() is used to check if a given variable is empty or not.
isset() returns true when the variable is not null whereas Empty() returns true if the variable is an empty string.
isset($variable) === (#$variable !== null)
empty($variable) === (#$variable == false)
I came here looking for a quick way to check if a variable has any content in it. None of the answers here provided a full solution, so here it is:
It's enough to check if the input is '' or null, because:
Request URL .../test.php?var= results in $_GET['var'] = ''
Request URL .../test.php results in $_GET['var'] = null
isset() returns false only when the variable exists and is not set to null, so if you use it you'll get true for empty strings ('').
empty() considers both null and '' empty, but it also considers '0' empty, which is a problem in some use cases.
If you want to treat '0' as empty, then use empty(). Otherwise use the following check:
$var .'' !== '' evaluates to false only for the following inputs:
''
null
false
I use the following check to also filter out strings with only spaces and line breaks:
function hasContent($var){
return trim($var .'') !== '';
}
Using empty is enough:
if(!empty($variable)){
// Do stuff
}
Additionally, if you want an integer value it might also be worth checking that intval($variable) !== FALSE.
I use the following to avoid notices, this checks if the var it's declarated on GET or POST and with the # prefix you can safely check if is not empty and avoid the notice if the var is not set:
if( isset($_GET['var']) && #$_GET['var']!='' ){
//Is not empty, do something
}
$var = '';
// Evaluates to true because $var is empty
if ( empty($var) ) {
echo '$var is either 0, empty, or not set at all';
}
// Evaluates as true because $var is set
if ( isset($var) ) {
echo '$var is set even though it is empty';
}
Source: Php.net
isset() tests if a variable is set and not null:
http://us.php.net/manual/en/function.isset.php
empty() can return true when the variable is set to certain values:
http://us.php.net/manual/en/function.empty.php
<?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";
}
?>
!empty will do the trick. if you need only to check data exists or not then use isset other empty can handle other validations
<?php
$array = [ "name_new" => "print me"];
if (!empty($array['name'])){
echo $array['name'];
}
//output : {nothing}
////////////////////////////////////////////////////////////////////
$array2 = [ "name" => NULL];
if (!empty($array2['name'])){
echo $array2['name'];
}
//output : {nothing}
////////////////////////////////////////////////////////////////////
$array3 = [ "name" => ""];
if (!empty($array3['name'])){
echo $array3['name'];
}
//output : {nothing}
////////////////////////////////////////////////////////////////////
$array4 = [1,2];
if (!empty($array4['name'])){
echo $array4['name'];
}
//output : {nothing}
////////////////////////////////////////////////////////////////////
$array5 = [];
if (!empty($array5['name'])){
echo $array5['name'];
}
//output : {nothing}
?>
Please consider behavior may change on different PHP versions
From documentation
isset() Returns TRUE if var exists and has any value other than NULL. FALSE otherwise
https://www.php.net/manual/en/function.isset.php
empty() does not exist or if its value equals FALSE
https://www.php.net/manual/en/function.empty.php
(empty($x) == (!isset($x) || !$x)) // returns true;
(!empty($x) == (isset($x) && $x)) // returns true;
When in doubt, use this one to check your Value and to clear your head on the difference between isset and empty.
if(empty($yourVal)) {
echo "YES empty - $yourVal"; // no result
}
if(!empty($yourVal)) {
echo "<P>NOT !empty- $yourVal"; // result
}
if(isset($yourVal)) {
echo "<P>YES isset - $yourVal"; // found yourVal, but result can still be none - yourVal is set without value
}
if(!isset($yourVal)) {
echo "<P>NO !isset - $yourVal"; // $yourVal is not set, therefore no result
}
<?php
$var = NULL;
var_dump(isset($var)); // bool(false)
var_dump(isset($unset_var)); // bool(false)
?>
isset($var) should return TRUE, since it has been set to NULL.
Is there any way to check for this?
Thanks!
use get_defined_vars() to get an array of the variables defined in the current scope and then test against it with array_key_exists();
Edited:
if you wanted a function to test existence you would create one like so:
function varDefined($name,$scope) {
return array_key_exists($name, $scope);
}
and use like so in any given scope:
$exists = varDefined('foo',get_defined_vars());
Should work for any scope.
Not very pretty, but...
array_key_exists('var', $GLOBALS);
(You can't use #is_null($var), because it evaluates to true either way [and it's not really good practice to suppress errors using the # operator...])
If it's a global, you can do:
if(array_key_exists('var', $GLOBALS))
if it's in global scope, you can try checking if the key exists in the $GLOBALS superglobal (using array_key_exists()).
but you're probably doing something wrong if you need to know this :)
Any unset var will evaluate to null:
php > $a = null;
php > var_dump($a === null);
bool(true)
php > var_dump($a === $b);
bool(true)
(using interactive console - php -a )
Aren't variables initialized to NULL by default? So, there isn't really a difference between one that hasn't been inited and one that you've set to NULL.