I have a form that outputs the following http string when the the form is submitted:
Field109=E01&Field112=E05&Field209=Enter+the+message+here%21&Field110=&Field111=&Field113=&Field114=&Field115=&Field116=&Field117=&Field118=&Field119=&Field120=&CreatedBy=public&DateCreated=2013-01-17+08%3A43%3A45&EntryId=14&IP=98.246.50.81&HandshakeKey=
In my PHP script that handles the submission, I check each Field to see if it is set.
The problem is, as you can see above, if the field in the form is empty when submitting, it still remains in the HTTP string and isset() thinks it is set and does processing I tell it to.
How do I check to see if the field is truly empty? For example Field110 and Field111 should be empty, but my PHP script thinks they are set.
if (isset($_GET["Field110"])) {
array_push($apnsarray, "E02");
}
if (isset($_GET["Field111"])) {
array_push($apnsarray, "E03");
}
Use empty()
if(!empty($_GET['Field110'])){
array_push($apnsarray, "E02");
}
// etc...
How do I check to see if the field is truly empty?
empty()
isset() determines if a variable is set and is not NULL. Whereas empty() will check if the value is empty.
So in your case isset() is returning true by the definition above. Instead use empty() for the values that require a value.
Well, what are the possible values?
If it might have a 0 and only a 0 in it, I'd recommend this:
if(isset($_GET['Field110']) && strlen(trim($_GET['Field110']) != 0) {
// not empty
}
But if it's only ever gonna consist of letters or something that isn't 0:
if(!empty($_GET['Field110'])) {
//not empty
}
This is from the empty() doc:
The following things are considered to be empty:
"" (an empty string)
0 (0 as an integer)
0.0 (0 as a float)
"0" (0 as a string)
NULL
FALSE
array() (an empty array)
$var; (a variable declared, but without a value)
empty()
Related
i couldn't figured it out what is the real difference functionality between empty() and $_POST["xxx"]==""?
empty() is a statement (unlike any function you could define) which will not trigger an E_NOTICE if called on a variable that is actually undefined. So it also include an isset check.
Determine whether a variable is considered to be empty. A variable is considered empty if it does not exist or if its value equals FALSE. empty() does not generate a warning if the variable does not exist.
Note that "equals FALSE" means an == comparison, so e.g. empty strings, a string containing a single zero, NULL, empty arrays are all considered empty.
The following things are considered to be empty (return true):
"" (an empty string)
0 (0 as an integer)
0.0 (0 as a float)
"0" (0 as a string)
NULL
FALSE
array() (an empty array)
$var; (a variable declared, but without a value)
BUT
$_POST["xxx"]==""
Return true when $_POST["xxx"] is an empty string
I don't understand the difference between isset() and !empty().
Because if a variable has been set, isn't it the same as not being empty?
ISSET checks the variable to see if it has been set. In other words, it checks to see if the variable is any value except NULL or not assigned a value. ISSET returns TRUE if the variable exists and has a value other than NULL. That means variables assigned a "", 0, "0", or FALSE are set, and therefore are TRUE for ISSET.
EMPTY checks to see if a variable is empty. Empty is interpreted as: "" (an empty string), 0 (integer), 0.0 (float)`, "0" (string), NULL, FALSE, array() (an empty array), and "$var;" (a variable declared, but without a value in a class.
Source :http://php.net/manual/en/types.comparisons.phpThis page shows the comparison of the empty(),is_null(),isset().
The type comparison tables gives answer of all question about these operators
http://php.net/manual/en/types.comparisons.php
And one more remark. empty() checks if the variable exists as well. I.e. if we perform empty() to the variable that wasn't declared, we don't receive an error, empty() returns 'true'. Therefore we may avoid isset() if next we need to check if the variable empty.
So
isset($var) && !empty($var)
will be equals to
!empty($var)
isset — Determine if a variable is set and is not NULL.
!empty — Determine whether a variable is NOT empty.
Isset return false if variable has not been set or it is null and return true if variable has been set and not null.
!empty return true if variable has been set and not empty. Empty string, empty array, "0",0 and false are defined as empty.
Use !empty when there is a condition already present which is checking for true or false.
isset is more basic. empty incorporates more checks, hence needs to be used with care.
I have a form with username and password and the value gets posted to check.php
when I have no input in username and password,(left blank), isset($_POST["username"]) and isset($_POST["password"]) returns true, which it should not be as I did not set anything.
But empty($_POST["username"] returns true as is expected.
can someone explain this behaviour of isset.
Thanks
If you submit form elements...
<input name='username'...
...but they're empty, it will fill the $_POST array with empty values by default. So, the variables are set, but they're empty ("").
What I usually do in this case is something like
if (isset($_POST['username'] && $_POST['username']) { ... }
In that case, it will check for if it's set (that is, is the form submitted) and if the values aren't empty. If they're empty ("") PHP will interpret as false and the condition will not be met.
That may be because your $_POST['username'] is set and may be empty, so to overcome check like this
if ((isset($_POST["username"]) && ($_POST["username"]!=""))
isset — Determine if a variable is set and is not NULL.
If a variable has been unset with unset(), it will no longer be set. isset() will return FALSE if testing a variable that has been set to NULL. Also note that a NULL byte ("\0") is not equivalent to the PHP NULL constant.
If multiple parameters are supplied then isset() will return TRUE only if all of the parameters are set. Evaluation goes from left to right and stops as soon as an unset variable is encountered.
refer :- http://php.net/manual/en/function.isset.php
In various PHP tutorials I see this syntax -
if ($_POST) {
do something
}
I want to know whether this is equivalent to either isset or !(empty) (either one) or has different properties.
It attempts to evaluate the expression and cast it to boolean.
See 'Converting to boolean' at http://php.net/manual/en/language.types.boolean.php to see which values will be equivalent to true and which to false.
It does NOT however check for array key existence (i.e. isset), so if you try if ($_GET['somekey']) but somekey does not exist, you will see PHP Notice: Undefined index: somekey and then false will be assumed.
The best practice would be to perform empty() or isset() checks manually first as fits.
Good question. You are adressing one of PHPs dark sides if you ask me.
The if statement
Like in any other language I can imagine if evaluates the parameter to either true or false.
Since PHP doesn't really know types you could put any expression as parameter which will then be casted to bool as a whole
Following values are considered to be "FALSE"
boolean FALSE
integer 0
float 0.0
empty string
string "0"
any array with zero elements
NULL e.g. unset variables or $var = null
SimpleXML objects when created from empty tags
EVERY other value or expression result is casted to bool TRUE
Now, knowing this, all we need to find out is, what an expression or function returns when executed
If no POST data is set, the following expression would be TRUE
$_POST == FALSE
The isset function
isset returns bool TRUE when the given variable is set and not null.
parameters can be variables, array elements, string offsets and data members of objects.
In PHP 5.4 they fixed the behaviour with string offsets
$var = FALSE;
isset( $var ) === TRUE;
$var === FALSE;
More here
http://de1.php.net/manual/en/function.isset.php
The empty function
Returns false when a variable is considered to be empty or does not exist.
Those values are considered empty:
Returns FALSE if var exists and has a non-empty, non-zero value. Otherwise returns TRUE.
The following values are considered to be empty:
"" (empty string)
0 (integer)
0.0 (float)
"0" (string)
NULL
FALSE
array() (empty array)
Also declared variables without value are empty
compare table
$var = FALSE;
isset($var) === TRUE;
empty($var) === TRUE;
$var === FALSE;
if ($_POST)
This will evaluate to true if there are any elements in the POST array.
if(isset($_POST))
This will always evaluate to true because the POST array is always set, but may or may not contain elements, therefore it is not equivalent to the first example.
if(!empty($_POST))
This however, is equivalent to the first example because empty() checks for contents in the array.
A good generic way of testing if the page was posted to is:
if($_SERVER['REQUEST_METHOD'] == 'POST')
$_POST:
this is used to find whether data is passed on using HTTP POST method and also extracting the variables sent through the same which are collected in an associative array
isset:
checks whether a variable is set(defined) or is NULL(undefined)
PHP.net is an invaluable source of information for figuring out the intricacies and quirks of the language.
With that said, those are not equivalent. The if statement converts the expression to a boolean value (see here for information on what is considered false).
isset is used to "determine if a variable is set and is not NULL."
empty determines whether a variable is empty, i.e., "it does not exist or if its value equals FALSE."
Best practice if you want to check the value of a variable but you aren't sure whether it is set is to do the the following:
if(isset($var) && $var) { ... }
ie check isset() AND then check the variable value itself.
The reason for this is that if you just check the variable itself, as per the example in your question, PHP will throw a warning if the variable is not set. A warning message is not a fatal error, and the message text can be suppressed, but it's generally best practice to write code in such a way that it doesn't throw any warnings.
Calling isset() will only tell you whether a variable is set; it won't tell you anything about the value of the variable, so you can't rely on it alone.
Hope that helps.
Does empty() function validate all of this cases:
1.var=null
2.var=empty string ""/" "
3.var=not set
Example for validate use (Should I add some more code for validation or empty() enough?):
if(!empty($userName)){
//some code
}
else{
echo "not valid user name"
}
Edit: should isset() used before empty() or empty() includes the isset() case?
Yes, it does. It's in the php documentation.
Given the following i would say it fits your needs:
The following things are considered
to be empty:
* "" (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)
EDIT:
should isset() used before empty() or
empty() include isset() case?
This depends on the usage. IF you are in a position where you cant be sure $username exists then you need to use isset first to avoid an error about a nonexistent variable. If on the other hand you are sure $username will always exist then you can jsut test for the empty value and leave it at that.
If you want to check if the user has filled in anything at all then empty() is ok. If you, on the other hand, want to check if the user filled in a username longer than 3 chars (strlen()) or only with alphanumeric chars (preg_match()) you will need some more tools ;)