Exception Handling in JavaScript

Javascript is an interpretation language. An interpreted language is a programming speech where the code is translated and executed line-by-line each clip it runs. The JavaScript engine reads your codification and checks for syntax error. The engine then action the codification line-by-line, translate it into machine instructions on the fly.

Even though JavaScript isn & # 8217; t compiled, exception handling is still all-important for pen racy and error-resistant code. Exception handling allows you to gracefully handle unexpected errors during runtime. Without it, your codification could crash, interrupting the exploiter experience.

What is Exception Handling?

There are several character of mistake that can occur in our code, like syntax error, reference errors, type errors, reach errors, etc. In order to deal all such errors, you will need exception treatment.

Exception handling aid you place and log errors, making it easier to debug and troubleshoot topic. For example, Operations such as dividing a non-zero routine by zero, calling a method with wrong arguing, or failing to read a file could give a JavaScript exception in our codification. If we have exception treatment in place, this could relieve our application from crash by throwing the precise erroneousness to the exploiter.

Importance of Exception Handling in JavaScript

In general, when an application happen an error, there is no use proceeding with it as it may cause an coating to crash.

So, it is important to handle any exception that could happen in code to hold the application up and running. If an unexpected answer is give and then processed by the company, the user become incorrect information and a bad impression of the application.

A well-written application should hold a good exception-handling mechanism and attack to various kinds of errors that are likely to happen within the application during exercise.

Types of Errors in JavaScript

Below are the mutual types of errors that we will mark in Javascript code.

1. Syntax error: This error occurs when the Javascript locomotive encounters invalid syntax while parsing your code.

For example,

console.log (`` Hello World ''; //Since the console.log is missing parentheses you will get it as syntax fault Uncaught SyntaxError: missing) after argument list

2. Reference fault: When we try to access a varying that is out of our scope or not yet defined, so this error will occur.

Take the below as an representative,

console.log (x); //When we try to print a variable that is ne'er defined we get a reference error Uncaught ReferenceError: x is not delimit

3. Type error: When you do an operation on the wrong value, this error will hap.

For example,

SUSA automates exploratory testing with persona-driven behavior, catching bugs that scripted automation misses.

num () //you are calling a map that is never defined and it will cast ta ype error Uncaught TypeError: num is not a function

4. URI error: This error occurs when there is a problem in encoding or decrypt the URI (Uniform Resource Identifier).

For illustration,

decodeURIComponent (`` % ''); //You are trying to decode an invalid URI component URIError: URI malformed

5. Range error: When the numeric value is outside of the allowed reach.

For example,

let arr = new Array (-1); //You are trying to make an array of negative length that is invalid Uncaught RangeError: Invalid array duration

What is an Error Object in JavaScript?

In JavaScript, an Error object represents an erroneousness that occur during the execution of your code. It provides information about the error, such as its type and a descriptive message. It will experience the properties below:

• Name:A string representing the type of fault (for example,& # 8220; TypeError & # 8221;, & # 8220; ReferenceError & # 8221;, & # 8220; SyntaxError & # 8221;).
• Message:A human-readable string describing the error.
• Cause:A property that can cite another error object, indicating the underlying cause of the current error.

Consider the below code that has the name, message, and campaign of the error inside it,

role divide (a, b) {if (b === 0) {throw new Error (`` Division by nil '', {//Adding cause belongings to the error function cause: {code: `` DIV_BY_ZERO '', dividend: a, divisor: b}});} return a / b;} try {//Dividing the number 10 by 0 watershed (10, 0);} catch (error) {console.log (error.name) console.log (error.message) console.log (error.cause.code); // `` DIV_BY_ZERO ''}

Your output will look like the following,

This has the error gens, error content, and error cause variable.

How to handle Exceptions in JavaScript?

Here are some of the agency how you can handle elision in JavaScript.

1. Throw argument

The throw statement throw a user-defined exception. It allows you to make a custom error. The exception can be a twine, number, boolean, or object.

With the stroke statement, the executing of the current office will stop (the statements after the throw won & # 8217; t be action), and control will be passed to the maiden catch block in the call deal. If no match block exists among caller functions, the program will terminate.

For example, you may want to throw an error if the value which we pass is not a turn. You can delineate like below to throw an exception if the variable we pass isn ’ t a number.

function isNumber (num) {if (isNaN (num)) {throw new Error ('Given value is not a number! ');}} isNumber (' A ')

Talk to an Expert

2. try…catch statements

The try…catch argument have a try cube and then a catch cube. The code written inside the try block will get accomplish first and if it throws any error so the catch block will throw the error mentioned inside it.

You can translate it better with the belowexample.Call a function that is never defined inside a try cube, and inside the match block, print the error saying it is an invalid function,

try {noSuchFunction ()} catch {console.log (`` There is no such function!! '')}

With the above code you might have noticed that yet though there is no such role present, the catch block deal the error and printed the fault message.

3. try…catch…finally statements

You can also add a final argument to your try…catch block and make your code look better. With the concluding block added, the part of codification interior will get executed regardless of whether the try cube throws an mistake or not.

For exemplar, let a,b & cbe the three variables. Define a asa number, bas a twine, and cas undefined.

const a= 10, b = 'string '; try {console.log (a/b); console.log (c); //Since the variable is vague, it will be passed on to catch} catch (error) {console.log ('An error caught '); console.log ('Error message: ' + erroneousness);} finally {console.log ('This will get executed by default! ');}

From the above screenshot, you might have noticed that even though the try cube has any error or not, the final block will get executed and throw the condition error message.

Best Practices for Exception Handling in JavaScript

Here are some of the best practices for using exception handling in Javascript:

• Always have just the piece of code which will throw an exception inside the try cube. Avoid having irrelevant code inside the try block.
• Don & # 8217; t catch generic errors unless dead necessary. Try to catch specific exceptions (for example, net errors and validation erroneousness) and handle them accordingly.
• Create custom error classes to typify specific error conditions. This makes debugging leisurely by providing clear error types.
• Use lumber for exclusion to ensure that you bewitch sufficient details to debug.
• Avoid catching errors if you don & # 8217; t plan to handle or log them. Let the erroneousness propagate up the call stack unless it ’ s critical to handle it at the current level.
• The ultimately block is executed after the try or catch block, disregardless of whether an error was thrown or not. Use it for resource cleanup (for instance, shut file, and clearing timeouts).

Why choose BrowserStack to run JavaScript Tests?

is a powerful cloud-based testing platform designed to streamline and enhance your web coating testing processes. Here is why you must choose BrowserStack to run JavaScript Tests:

• BrowserStack render a comprehensive cloud-based platform with accession to a wide variety of real browsers and devices, allowing you to try your JavaScript code across different environments with ease, significantly trim the need to manage physical device and streamlining your testing process.
• It also seamlessly mix with popular JavaScript testing framework like,, and, make it efficient to action your tests on multiple platforms.
• Bring down test execution times by parallelizing your tests on Automate. And screen your internally hosted apps just as seamlessly.
• Use the that allows you to desegregate your test suites with BrowserStack Automate in minutes. Simply instal the SDK, set up a YAML file, and trigger your trial to get started.
  Also, using the SDK makes it easygoing to leverage features like parallel orchestration and local examination, with zero code changes.
• BrowserStack Automate allow you to seamlessly collaborate and debug with a range of logging tools for inexhaustible exploiter from your organization. Use these logs to debug your failed test lawsuit and fix them with ease.

Conclusion

Whenever our application throws an fault, it is really difficult for us to debug an issue. Having exception handling in our codification base will facilitate us to debug the issue relatively earlier as we will get to know the reason for such errors easily.

Additionally, integrate best practices like logging, cleansing with finally, and minimum reliance on global error handlers insure your code remains reliable and easier to debug in complex scenarios. A serious-minded approach to exception handling makes your covering more resilient and user-friendly.

For automated testing of exception care across multiple browsers, try. It furnish a scalable, cloud-based Selenium testing platform that helps identify JavaScript errors betimes and ensures a seamless and reliable user experience.

Related Guides