Differences between throwing errors, returning error objects, and using callbacks in Javascript

Question

Differences between throwing errors, returning error objects, and using callbacks in Javascript

Currently, I am developing an assembler and simulator for a simplistic assembly language that my computer science students use during their classes. The project is being written in JavaScript with the intention of creating a user-friendly interface in the web browser to help students visualize how each instruction impacts the state of the machine.

One particular challenge I am facing is determining the most effective method for conveying error messages from the assembler when it encounters invalid assembly code. At this stage, the assembler's API is quite basic:

var assembler = ... // Obtain the assembler object
var valid_source = "0 mov r1 r2\n1 halt";
var valid_binary = assembler.assemble(valid_source);  // Returns string of binary data (0's and 1's)

var invalid_source = "foo bar baz!";
var invalid_binary = assembler.assemble(invalid_source); // What should be the response in this case?

I have considered several approaches for addressing this issue:

Create and throw a new JavaScript Error object. However, this seems like excessive handling since users may not necessarily need or want intricate details like a stack trace.
Return a string or object containing specific error information. This way, the assembler's user can decide how to handle any errors that arise.

Modify the assembler's API to utilize a callback function instead:

assembler.assemble(source, function(binary, error) {
  if (error) {
    // Handle the error
  }
  // Process the binary otherwise
});

Or perhaps explore a different approach altogether?

Any suggestions, insights, or feedback would be highly valued.

javascript assembly error-handling

Answer 1

Answer №1

In my opinion, all three options could be effective. However, I have a different perspective:

I would avoid the third option because it may give the impression that it is an asynchronous function when it actually isn't.

My preference would be to choose either option 1 or 2. Option 1 may seem a bit excessive, but I believe it closely resembles how compilers operate. Exiting without a zero code and adding a try/catch block to handle errors would be necessary.

Alternatively, returning an error object appears to be the most suitable choice for me.

I suggest returning an Error object, which can be done as follows:

return new Error('Parsing error');

// Alternatively, with an error name
var error = new Error('Parsing error');
error.name = 'PARSING_ERROR';
return error;

An advantage of using the error object is that it provides access to the stack trace and other useful information. More details can be found here.

Furthermore, to determine if there was an error, you simply need to check the variable type:

if (typeof valid_binary === 'string') { /* no error */ }

// Or

if (typeof valid_binary === 'object') { /* error */ }

Wishing you the best of luck!

Answer 2

In my opinion, all three options could be effective. However, I have a different perspective:

I would avoid the third option because it may give the impression that it is an asynchronous function when it actually isn't.

My preference would be to choose either option 1 or 2. Option 1 may seem a bit excessive, but I believe it closely resembles how compilers operate. Exiting without a zero code and adding a try/catch block to handle errors would be necessary.

Alternatively, returning an error object appears to be the most suitable choice for me.

I suggest returning an Error object, which can be done as follows:

return new Error('Parsing error');

// Alternatively, with an error name
var error = new Error('Parsing error');
error.name = 'PARSING_ERROR';
return error;

An advantage of using the error object is that it provides access to the stack trace and other useful information. More details can be found here.

Furthermore, to determine if there was an error, you simply need to check the variable type:

if (typeof valid_binary === 'string') { /* no error */ }

// Or

if (typeof valid_binary === 'object') { /* error */ }

Wishing you the best of luck!

Differences between throwing errors, returning error objects, and using callbacks in Javascript

Answer №1

Similar questions

Route.post() is in need of a callback function, however, it was provided with an [object String

Display images that have been uploaded on the page either as a grid view or a list of

Having trouble retrieving data from MongoDB and rendering it on an HTML page

What is the process for restarting the timer within a timer controlled by the react-countdown component?

``Why is my setFeatureState function not updating the value in my Mapbox map

Module not found in Node.js Express JS

Combinations of Typescript dependent unions

Transmit information to the controller using jQuery in a C# MVC environment

Mastering Data Transfer in jQuery: A Guide to Migrating Event Information from .on(dragstart) to

A guide on linking an object in strapi V4 to a React app

Check for pattern using JavaScript regular expression

End your Idp session and log out using passport-saml

Combining PHP Variable with URL String

Obtain the selected dropdown value and transfer it to the controller seamlessly without the need to reload the page

Performing an Ajax post request to a PHP script in order to retrieve a PHP variable using XMLHttpRequest

How can I fix the position of the close button when using the paper component of a modal in material ui to ensure responsiveness on the screen

Capturing keydown events exclusively in the topmost layer of the HTML document

What could be causing jQuery animate to malfunction on mobile devices when a viewport is present?

Calculating the hour difference between two time stamps (HH:MM:SS a) using moment.js

Is it possible to use multiple AJAX requests to automatically fill out form fields?