Rocky D
λ. Code and Combat in Harmony


λ. Code and Combat in Harmony

Error Handling in JavaScript: Either vs Try/Catch

Photo by visuals on Unsplash

Error Handling in JavaScript: Either vs Try/Catch

Handle Errors in Functional Way

Rocky D's photo
Rocky D
·Jan 8, 2023·

3 min read

Table of contents

  • What is the Either type?
  • Comparison with try/catch
  • Conclusion:

Error handling is an important aspect of any programming language, and JavaScript is no exception. In this post, we will compare two approaches for handling errors in JavaScript: the Either type and the try/catch statement.

What is the Either type?

Functional programming is a programming paradigm that emphasizes the use of pure functions and immutable data. It is based on the idea that programs can be thought of as a series of transformations on data, and that these transformations can be composed in a modular way to create complex programs.

The Either type is an important tool in functional programming, as it allows developers to handle errors and exceptions in a way that is composable and easy to understand. It is often used in combination with other functional programming concepts, such as monads and monoids, to create powerful and expressive error-handling systems.

In JavaScript, the Either type can be implemented manually or through the use of libraries. One popular library for working with Either in JavaScript is monet.

Here is an example of using the Either type from the monet library:

In this example, we define two functions, divide and multiply, that return a Monet Either object. The divide function returns a Left either with an error if the denominator is 0, and a Right either with the result of the division if the denominator is non-zero. The multiply function works similarly.

We then use the flatMap method on the result of divide(4, 2) to pass the result (2) to the multiply function. The flatMap method allows us to easily compose these two operations, as it will only pass the value to the next function if the previous function returned a Right either.

Finally, we use the cata method on the result of the chained operation to either log the success value or print the error, depending on the type of either returned.

This demonstrates how the Either solution can be easily composed, as we can chain multiple operations together using the flatMap method.

Comparison with try/catch

Now let's compare the Either type with the try/catch statement, a popular approach for handling errors in JavaScript.

Here is an example using try/catch for dividing and multiplying numbers:

In this example, the divide and multiply functions throw errors if certain conditions are met. The try/catch statement is used to catch any errors that may be thrown during the execution of these functions.


So, how do Either and try/catch compare? One advantage of Either is that it allows developers to clearly distinguish between successful and failed operations. In the try/catch example, it is not immediately clear.


  • Pros:

    • Provides a clear separation between successful and failed operations

    • Allows for easy composition of multiple error-handling operations

    • Can be implemented manually or through the use of libraries, such as Monet

  • Cons:

    • Requires additional code to be written in order to use the Either type

    • May be more difficult for developers who are not familiar with functional programming concepts


  • Pros:

    • Built-in to the JavaScript language

    • Familiar to most developers

  • Cons:

    • Can lead to verbose and hard-to-read code, especially when multiple try/catch blocks are nested

    • Does not provide a clear separation between successful and failed operations

    • Does not support easy composition of multiple error-handling operations

In my opinion, the Either version is more suitable for use in a larger application where the component may be used by other components. This is because Either allows for easy composition of different components and provides a clear indication of success or failure. On the other hand, Try/Catch may be more appropriate for use in a component that is not intended to be reused by other components.

Share this