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

Identifying when a fetch operation has completed in vue.js can be accomplished by utilizing promises

Having trouble implementing button functionality in a web app using JS, jQuery, HTML, and CSS along with an API integration

Tips for positioning an advertisement at the center of a full-screen HTML5 game

What is the best way to simulate global variables that are declared in a separate file?

Is it feasible to utilize the translate function twice on a single element?

Can you explain the concept of a "cURL" and guide me on how to use it effectively?

Constructing a JSON schema for a dynamic aggregate query

Are there any methods to alter the current preFilters within jQuery?

Filtering in AngularJS can be performed by checking if a value in a specific key of one array is also present as a value in a specific

Uploading files seamlessly without the need for refreshing the page

Error encountered while retrieving data from Firebase and storing it in an array within an IONIC application

Navigational elements, drawers, and flexible designs in Material-UI

The JQuery function fails to execute following a successful Ajax request

Generating an array within the custom hook results in the value being re-rendered with each change in state

When data is stored in Internet Explorer's cache, any changes made are not being reflected in

Encourage the client to maintain active listening throughout the entire conversation, rather than just listening once

Exploring the POST method functionality in AJAX

Issues with Javascript code syntax

Does Three.js lighting adjust according to the bundler used?

Mastering the art of tab scrolling in VueJS using Bootstrap-vue