3

I apologise if this has already been answered somewhere, but I haven't managed to find an answer so far - maybe I'm searching for the wrong thing!

I am trying to figure out how to handle errors in my OO PHP system, which is used to generate web pages. Hopefully this example will explain what I mean.

Imagine I have a Content class, a Form class and a FormObject class, which hold all the information on page content, web forms and form fields. All classes can run multiple MySQL queries via the DB class. Users can create new content or forms in the back-end. When they do this, I use the classes to create and store the data in the database.

I also have a System class, which is used to generate the web pages. The System class checks what should be displayed on the front-end, builds the appropriate Content and Form objects, then generates the HTML and outputs it to the screen.

I have some checks for serious errors, which stop the code from going any further. However, the problem is that I want to feed back some "soft errors" to the front-end. For example, maybe the System class builds a Form object, which in-turn builds the fields using the FormObject class. The FormObject class queries the database for a field name, but a field name is not found. So the DB class returns an error. I want to be able to feed back a message to the front-end that says the field name has not been found.

What is the best way to get that "soft error" message back to the System class, so it can be outputted to the front-end? I realise it is fairly simple in this particular example, but as more classes are added and, crucially, more levels are added, the problem becomes a bit bigger.

One way I thought of doing this was to have an Error class. The system would create an Error object and pass it on to each Content and Form object as they are created. The Form class would pass the same Error object to the FormItem class. Whenever an error is found, it is logged via a method in the Error class. The system can then access the original Error object and output all the errors. However, as the system grows, more classes are added, and more objects are created, it could get quite confusing. Is there a better way?

Improve this question
8
  • Maybe you could throw an Exception and then add a default exception handler that would log the error or display something to the browser. Commented Jun 19, 2015 at 19:19
  • Thanks Mike. I don't particularly want to just output to screen from where the error is found, as the idea is to generate the HTML and then output it all at once. If I echo an error, for example, it will appear above all of the HTML. I would like to display all soft errors in a particular error div within the HTML. If I log the error, where would I log it to? Could I store it in a global variable? Commented Jun 19, 2015 at 19:24
  • You wrote 7 paragraph when all you needed is to show a small snippet of code Commented Jun 19, 2015 at 19:24
  • 1
    My system is much more complicated than the example I gave. I was trying to simplify the problem. Commented Jun 19, 2015 at 19:25
  • Class that handles error codes - doesn't sounds so bad, at least i do using this technique in my projects. For example, if some function will return error code - the class will handle it and return description of the error or other data... Commented Jun 19, 2015 at 19:35

2 Answers 2

Reset to default
3

You might want to use either

  1. something global that all classes can access (e.g. a global variable or a Singleton), or
  2. something that is passed in to all instantiations of classses producing what you call 'soft errors'

to collect such errors. You then want to use whatever you collected and add it to the output in your System class somehow.

To be more specific...

This is an example for the solution using a global:

global $softErrorMessages = array();

class A
{
  function sampleFunctionA()
  {
    // [...]
    // some code setting $result to some valid value
    // or to false if an error occured

    if($result === false) // check for validity
    {
      global $softErrorMessages;
      $softErrorMessages[] = "The sample function A caused a soft error";
      return;
     }

    // [...]
    // some code requiring a valid $result
  }
}

If you use such a global, you can then easily access it from your System class and put its contents into the right places of your output.

However, if you perform unit tests, you might not want to use globals or global-like solutions (like singletons). So here is an example for an 'error collection' approach:

class ErrorCollector
{
  private $errors = array();

  function addError($error)
  {
    $this->errors[] = $error;
  }

  function getErrors()
  {
    return $this->errors;
  }
}

class A
{
  private $errorCollector;

  function __construct(/* your additional parameters */, ErrorCollector $errorCollector)
  {
    // [...]
    // additional instantiation stuff

    $this->errorCollector = $errorCollector;
  }

  function sampleFunctionA()
  {
    // [...]
    // some code setting $result to some valid value
    // or to false if an error occured

    if($result === false) // check for validity
    {
      $this->errorCollector->addError("The sample function A caused a soft error");
      return;
     }

    // [...]
    // some code requiring a valid $result
  }

}

You would instantiate the ErrorCollector only once and then pass it to all other class instantiations. Then you let your objects perform their duties (and possibly add soft errors to the ErrorCollector). Once they're done, your System class would then get all the error messages and - again - place them at the right place of your output.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

I would go with the second method. Dependency injection is much better than global variables.
0

Exceptions is a convenient mechanism to handle errors. FormObject can throw an exception of some SoftErrorException class if DB returns an error. And then in System you are catching this exception and render it to front-end.

class System {

    public function showFormAction() {

        try {
            $form = ... // create a form
            $this->renderForm($form);
        } catch (SoftErrorException $e) {
            $this->handleSoftError($e);
        }

    }

    public function handleSoftError(SoftErrorException $e)
    {
        // Do whatever you want with exceptions: render it
        // $this->renderErrorPage($e->getMessage());
        // or collect them and show after
        // $this->errors[] = $e;
    }



}
Improve this answer

1 Comment

If I understood things correctly, this code doesn't quite agree with Ian's concept of soft errors: Soft errors should NOT terminate the individual worker methods but should only be collected somehow in order to be displayed later (after completion of these worker functions). However, by throwing exceptions your code would terminate these worker methods without allowing them to complete.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.