One exception in a collection operation like for-each or map/collect stops the processing of all the other elements. Instead of letting the whole task blow up it is often more desirable to skip those elements causing failures, log the errors (and possibly notify the user about the failing elements), but have all other elements processed. Examples for such operations are: sending bulk mails to users, bulk import/export, lists in user interfaces etc., and common errors are, for example, NullPointerExceptions, database errors or wrong email addresses.
Here’s some simple code for robust and reusable for-each and map operations in JavaScript:
function robustForEach(array, callback) {
var failures = [];
array.forEach(function(elem, i) {
try {
callback(elem, i);
} catch (e) {
failures.push({element: elem, index: i, error: e});
}
});
return failures;
}
function robustMap(array, callback) {
var result = { array: [] };
result.failures = robustForEach(array, function(elem, i) {
result.array.push(callback(elem, i));
});
return result;
}
Similar code can be easily implemented in other languages like Java (especially with Java 8 streams), Groovy, Ruby, etc.
If you decide to log the errors, you have to choose between two possible log strategies: one log operation per error, which can be annoying if you get a mail for each logged error, or one log operation bundling all occurred errors (make sure that a failing toString can’t spoil the whole bunch again).
function logAny(failures) {
failures.forEach(function(fail) {
log.error(failMessage(fail));
});
}
function logAnyBundled(failures) {
if (failures.length == 0) {
return;
}
log.error(failures.map(function(fail) {
return failMessage(fail);
}).join('\n'));
}
function failMessage(fail) {
return "Could not process '" +
fail.element + "': " + fail.error;
}
You can easily combine the map and log operations:
function robustMapAndLog(array, callback) {
var result = robustMap(array, callback);
logAny(result.failures);
return result.array;
}
Example usage:
var numbers = [1, 2, 3, 4, 5, 6, 7, 8];
var result = robustMapAndLog(numbers, function(n) {
if (n == 5) {
throw 'bad apple';
}
return n * n;
});
print(result);
// Error log output:
// Could not process '5': bad apple
// Output:
// [ 1, 4, 9, 16, 36, 49, 64 ]
One element could not be processed due to an error, but all other elements were not affected.
Conclusion
Be aware of the bad apple possibility for every loop you write (explicitly or implicitly) and consciously choose the appropriate error handling strategy depending on the situation. Don’t let indifference decide the fate of your bulk operations.
Layer 0: Executable
Schneide Blog 
