Hello,
I am a C++ programmer starting with PHP. I find that I lose most of debugging time (and my selfesteem!) due to undefined variables. From what I know the only way to deal with them is to watch the output at execution time.
Are other strategies to notice earliers these faults? (something like with C++ that a single compile gives you all the clues you need)
Thanks for any insights
From what I know the only way to deal with them is to watch the output at execution time.
Not really: To prevent these notices from popping up, you just need to make sure you initialize variables before accessing them the first time. We (sadly IMO) don't have variable declaration in PHP, but initializing them in the beginning of your code block is just as well:
$my_var = value;
Using phpDocumentor syntax, you can also kind of declare them to be of a certain a type, at least in a way that many IDEs are able to do code lookup with:
/** @desc optional description of what the variable does
@var int */
$my_var = 0;
Also, you can (and sometimes need to) use isset() / empty() / array_key_exists() conditions before trying to access a variable.
I agree this sucks big time sometimes, but it's necessary. There should be no notices in finished production code - they eat up performance even if displaying them is turned off, plus they are very useful to find out typos one may have made when using a variable. (But you already know that.)
Log your E_NOTICE messages to a text file. You can then process logs with automated scripts to indicate files and lines where these are raised.
No. In PHP, you can only know a variable doesn't exist when you try to access it.
Consider:
if ($data = file('my_file.txt')) {
if (count($data) >= 0)
$line = reset($data);
}
var_dump($line);
You have to restructure your code so that all the code paths leads to the variable defined, e.g.:
$line = "default value";
if ($data = file('my_file.txt')) {
if (count($data) >= 0)
$line = reset($data);
}
var_dump($line);
If there isn't any default value that makes, this is still better than isset because you'll warned if you have a typo in the variable name in the final if:
$line = null;
if ($data = file('my_file.txt')) {
if (count($data) >= 0)
$line = reset($data);
}
if ($line !== null) { /* ... */ }
Of course, you can use isset1 to check, at a given point, if a variable exists. However, if your code relies on that, it's probably poorly structured. My point is that, contrary to e.g. C/Java, you cannot, at compile time, determine if an access to a variable is valid. This is made worse by the nonexistence of block scope in PHP.
1 Strictly speaking, isset won't tell you whether a variable is set, it tell if it's set and is not null. Otherwise, you'll need get_defined_vars.
Just watch not to do operations that requires variable value when using it first time, like concat operator .=
If you are C++ programmer you must be used to declare all variables, Do something simillar to this in PHP by zero-ing variables or creating empty array if you want to use them.
Pay attention to user input, be sure you have register globals off and check inputs from $_GET and $_POST by isset().
You can also try to code classes against structural code, and have every variable created at begining of class declaration with correct privacy policy.
You can also separate application logic from view, by preparing all variables that have to be outputted first, and when it goes to display it, you will be know which variables you prepared.
I believe that various of the Code Coverage tools that are available for PHP will highlight this.
Good practice is to define all variable before use i.e set a default value
$variable = default_value;
This will solve most problems. As suggested before use xdebug or built-in debugging tools in editors like Netbeans
Personally, I try and set variables, even if it's with an empty string, array, Boolean etc. Then use a function such as isset() before using them. For example:
$page_found = false;
if ($page_found==false) {
// do page not found stuff here
}
if (isset($_POST['field'])) {
$value = $_POST['field'];
$sql = "UPDATE table SET field = '$value'";
}
And so on. And before some smart-ass says it: I know that query's unsafe. It was just an example of using isset().
During development stages use
error_reporting(E_ALL);
witch will show every error that has caused, all NOTICE errors and etc.
Kepp an eye on your error_log aswell, that will show you errors
use an error reporting system, example:
http://php.net/manual/en/function.set-error-handler.php
class ErrorReporter
{
public function catch($errno, $errstr, $errfile, $errline)
{
if($errno == E_USER_NOTICE && !defined('DEBUG'))
{
//Catch all output buffer and clear states, redirect or include error page.
}
}
}
set_error_handler(array(new ErrorReporter,'catch'));
few other tips is always use isset for variables that you may / may not have set because of a if statement lets say.
always use if(isset($_POST['key'])) or even better just use if(!empty($_POST['key'])) as this checks if the key exists and if the value is NOT empty.
make sure you know your comparison operators aswell, languages like C# use == to check bool state where as in php to check data-types you have to use === and use == to check value states, and single = to assign a value!
if you want to hide error of undefined variable, then use @ .
example: @$var
Unless I'm missing something, then why is no one suggesting to structure your page properly? I've never really had an ongoing problem with undefined variable errors.
An idea on structuring your page
Define all your variables at the top, assign default values if neccessary and then use those variables from there. That's how I write web pages and I never run into undefined variable problems.
Don't get in the habbit of defining variables only when you need them, this quickly creates spaghetti code and can be very difficult to manage.
No one likes spagehtti code
If you show us some of your code we might be able to offer suggestions on how you can better structure it to resolve this sorts of errors. You might be getting confused coming from a C background, the flow may work differently to web pages.
Thank you all for your replies. I was rather concerned on locating typos but as I've digged into PHP and your answers I see that the language is quite different from C++ in it's essence. The ability to create dynamically variables is inherent to the language. Maybe on a future version some option to force variable declarations per module at the expense of that dynamism would be useful on certain projects.
