Best practice for processing a list of items

Question

I have a list of objects that need to be processed in some way. That way may not be correct for an item and thus raise an exception. In pseudo-code, it would look like:

proccessItems (list)
  error = new empty list
  for item in list:  
    try:
      process_item(item)
    catch Whatever, err:
      error.append(err)
  return error

Is there a pattern for doing this sort of things? Are there any anti-patterns to avoid?

A better code (exception not used for control flow), but still following the same logic would be:

proccessItems (list)
  error = new empty list
  for item in list:  
    ret = process_item(item)
    if null != ret 
      error.append(ret)
  return error

Answer 1

First of all, you shouldn't use exceptions for normal logic flow.

You should ask yourself why you are trying to iterate over items which you can't process in the first place. Probably designing the code in such a way you only have items in your list which you can process is a better idea.

In case you do feel like all those items belong in that one list. Instead of throwing an exception you should still opt to use a conditional check (or polymorphism) to see whether the item is suitable for processing.

I can't specify 'official' anti-patterns but I would consider the following:

• Using exceptions for logic flow.
• Using type checking or other conditional checks instead of proper design/polymorphism.

Answer 2

I would pass the error list to the process_item function as well, then you'd have a simple iterator and you wouldn't need to throw exceptions to be caught by the proccessItems function.

That way maybe you could replace the exceptions for simple error messages ( like a string ) and avoid using them for control flow since that is not why they were designed in the first place. ( using them like this is a bad practice )

Keep in mind that exceptions ( depending on the language ) are expensive operations so given a large enough list the current example could be a problem.