# Error Handling in JavaScript: Either vs Try/Catch

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`](https://monet.github.io/).

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

%[https://codesandbox.io/embed/competent-neumann-shy2zq?fontsize=14&hidenavigation=1&theme=dark&view=editor] 

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:

%[https://codesandbox.io/embed/async-dust-mjxf4d?fontsize=14&hidenavigation=1&theme=dark&view=editor] 

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.

## Conclusion:

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.

**Either**

* 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
        

**Try/Catch**

* 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.