Throw and throws in javascript

JavaScript Errors

The try statement defines a code block to run (to try).

The catch statement defines a code block to handle any error.

The finally statement defines a code block to run regardless of the result.

The throw statement defines a custom error.

Errors Will Happen!

When executing JavaScript code, different errors can occur.

Errors can be coding errors made by the programmer, errors due to wrong input, and other unforeseeable things.

Example

In this example we misspelled «alert» as «adddlert» to deliberately produce an error:

try adddlert(«Welcome guest!»);
>
catch(err) document.getElementById(«demo»).innerHTML = err.message;
>

JavaScript catches adddlert as an error, and executes the catch code to handle it.

JavaScript try and catch

The try statement allows you to define a block of code to be tested for errors while it is being executed.

The catch statement allows you to define a block of code to be executed, if an error occurs in the try block.

The JavaScript statements try and catch come in pairs:

JavaScript Throws Errors

When an error occurs, JavaScript will normally stop and generate an error message.

The technical term for this is: JavaScript will throw an exception (throw an error).

JavaScript will actually create an Error object with two properties: name and message.

The throw Statement

The throw statement allows you to create a custom error.

Technically you can throw an exception (throw an error).

The exception can be a JavaScript String , a Number , a Boolean or an Object :

If you use throw together with try and catch , you can control program flow and generate custom error messages.

Input Validation Example

This example examines input. If the value is wrong, an exception (err) is thrown.

The exception (err) is caught by the catch statement and a custom error message is displayed:

Please input a number between 5 and 10:

Test Input

function myFunction() const message = document.getElementById(«p01»);
message.innerHTML = «»;
let x = document.getElementById(«demo»).value;
try <
if(x.trim() == «») throw «empty»;
if(isNaN(x)) throw «not a number»;
x = Number(x);
if(x < 5) throw "too low";
if(x > 10) throw «too high»;
>
catch(err) message.innerHTML = «Input is » + err;
>
>

HTML Validation

The code above is just an example.

Modern browsers will often use a combination of JavaScript and built-in HTML validation, using predefined validation rules defined in HTML attributes:

You can read more about forms validation in a later chapter of this tutorial.

The finally Statement

The finally statement lets you execute code, after try and catch, regardless of the result:

Syntax

try <
Block of code to try
>
catch(err) <
Block of code to handle errors
>
finally <
Block of code to be executed regardless of the try / catch result
>

Example

function myFunction() <
const message = document.getElementById(«p01»);
message.innerHTML = «»;
let x = document.getElementById(«demo»).value;
try <
if(x.trim() == «») throw «is empty»;
if(isNaN(x)) throw «is not a number»;
x = Number(x);
if(x > 10) throw «is too high»;
if(x < 5) throw "is too low";
>
catch(err) <
message.innerHTML = «Error: » + err + «.»;
>
finally <
document.getElementById(«demo»).value = «»;
>
>

The Error Object

JavaScript has a built in error object that provides error information when an error occurs.

The error object provides two useful properties: name and message.

Error Object Properties

Property	Description
name	Sets or returns an error name
message	Sets or returns an error message (a string)

Error Name Values

Six different values can be returned by the error name property:

Error Name	Description
EvalError	An error has occurred in the eval() function
RangeError	A number «out of range» has occurred
ReferenceError	An illegal reference has occurred
SyntaxError	A syntax error has occurred
TypeError	A type error has occurred
URIError	An error in encodeURI() has occurred

The six different values are described below.

Eval Error

An EvalError indicates an error in the eval() function.

Newer versions of JavaScript do not throw EvalError. Use SyntaxError instead.

Range Error

A RangeError is thrown if you use a number that is outside the range of legal values.

For example: You cannot set the number of significant digits of a number to 500.

Example

let num = 1;
try num.toPrecision(500); // A number cannot have 500 significant digits
>
catch(err) document.getElementById(«demo»).innerHTML = err.name;
>

Reference Error

A ReferenceError is thrown if you use (reference) a variable that has not been declared:

Example

let x = 5;
try x = y + 1; // y cannot be used (referenced)
>
catch(err) document.getElementById(«demo»).innerHTML = err.name;
>

Syntax Error

A SyntaxError is thrown if you try to evaluate code with a syntax error.

Example

try <
eval(«alert(‘Hello)»); // Missing ‘ will produce an error
>
catch(err) <
document.getElementById(«demo»).innerHTML = err.name;
>

Type Error

A TypeError is thrown if you use a value that is outside the range of expected types:

Example

let num = 1;
try num.toUpperCase(); // You cannot convert a number to upper case
>
catch(err) document.getElementById(«demo»).innerHTML = err.name;
>

URI (Uniform Resource Identifier) Error

A URIError is thrown if you use illegal characters in a URI function:

Example

try <
decodeURI(«%%%»); // You cannot URI decode percent signs
>
catch(err) <
document.getElementById(«demo»).innerHTML = err.name;
>

Non-Standard Error Object Properties

Mozilla and Microsoft define some non-standard error object properties:

fileName (Mozilla)
lineNumber (Mozilla)
columnNumber (Mozilla)
stack (Mozilla)
description (Microsoft)
number (Microsoft)

Do not use these properties in public web sites. They will not work in all browsers.

Complete Error Reference

For a complete reference of the Error object, go to our Complete JavaScript Error Reference.

Источник

Mastering ‘throw’ and ‘throws’ in JavaScript: Syntax, Best Practices, and Tips

Learn how to use ‘throw’ and ‘throws’ statements in JavaScript to create custom error messages, handle exceptions, and control program flow. Get tips, syntax examples, and best practices.

• What is the “throw” statement in JavaScript?
• What is the “throws” keyword in Java?
• JavaScript — Throw vs. Return Error
• How to create a user-defined exception with “throw”?
• How to handle errors with try-catch?
• Best practices and tips for using “throw” in JavaScript
• Other examples of code for using ‘throw’ and ‘throws’ in JavaScript
• Conclusion
• What is throw and throws?
• What is throw in JavaScript?
• Can we use throw and throws together?
• What’s the difference between throw error (‘ MSG ‘) vs throw new error (‘ MSG ‘) in JavaScript?

As a JavaScript developer, you know that errors can occur in your code that can cause your program to stop running or produce unexpected results. Luckily, JavaScript provides a powerful tool to handle these errors: the throw keyword. Understanding how to use throw correctly can help you create more reliable and accurate code. In this article, we’ll cover the key points of using throw in JavaScript, including syntax, best practices, and common issues.

What is the “throw” statement in JavaScript?

The throw statement is used to generate a custom error message in JavaScript. When an error occurs, the program will stop and generate an error message. The throw keyword is used to explicitly throw an exception from a method or any block of code.

Here is an example of the syntax for using the throw statement:

throw "An error has occurred." 

This will generate an error message that says “An error has occurred.”

What is the “throws” keyword in Java?

The throws keyword in Java is used to declare which exceptions can be thrown from a method. This keyword is similar to throw in JavaScript, but it is used in a different way. Here is an example of the syntax for using the throws keyword in Java:

public void myMethod() throws IOException <> 

This example declares that the myMethod() function can throw an IOException .

JavaScript — Throw vs. Return Error

In this video we will discuss the difference between throwing an error vs returning an error in Duration: 11:41

How to create a user-defined exception with “throw”?

The throw statement can be used to create a user-defined exception . This allows you to generate custom error messages that are specific to your program. Here is an example of the syntax for creating a user-defined exception with throw :

throw new Error("This is a custom error message.") 

This will generate an error message that says “This is a custom error message.”

How to handle errors with try-catch?

The try statement lets you test a block of code for errors. The catch statement lets you handle the error if one occurs. Here is an example of the syntax for using try-catch :

In this example, if an error occurs in the try block, the catch block will handle it.

Best practices and tips for using “throw” in JavaScript

Use “throw” to create accurate error messages and to control the flow of your program.

The throw statement is a powerful tool for generating custom error messages and controlling the flow of your program. By using throw to generate accurate error messages, you can make your code easier to debug and maintain. Additionally, by using throw to control the flow of your program, you can create more robust and reliable code.

Be sure to catch the thrown exception and handle it properly.

When you use throw to generate an exception, you need to make sure that you catch the exception and handle it properly. If you don’t catch the exception, your program will stop running and generate an error message. By handling the exception properly, you can prevent your program from crashing and provide a better user experience.

When using ES6 classes, extend Error via a class to preserve stack traces.

When you use ES6 classes to create custom errors , it’s important to extend the Error class. This allows you to preserve stack traces, which can be helpful for debugging your code. Here is an example of how to extend the Error class:

class CustomError extends Error < constructor(message) < super(message); this.name = "CustomError"; >> 

By extending the Error class, you can create custom errors that preserve stack traces.

Use the @throws tag in JSDoc to document an error that a function might throw.

When you write documentation for your code using JSDoc, you can use the @throws tag to document an error that a function might throw. This makes it easier for other developers to understand how to use your code and handle errors properly. Here is an example of how to use the @throws tag:

/** * A function that throws an error. * * @throws If an error occurs. */ function myFunction() < // code block >

By using the @throws tag, you can document the errors that your function might throw.

Always handle errors properly to prevent your program from terminating unexpectedly.

Handling errors properly is important for creating robust and reliable code. By handling errors properly, you can prevent your program from terminating unexpectedly and provide a better user experience. Always make sure to catch exceptions and handle them properly.

Other examples of code for using ‘throw’ and ‘throws’ in JavaScript

In Javascript , for instance, js throw error code example

In Javascript , for example, how to catch and throw error js code example

In Javascript case in point, js throw new error code example

In Javascript , for example, javascript syntax of throw statement code sample

In Javascript as proof, javascript syntax of throw statement code sample

Conclusion

The throw keyword in JavaScript is a powerful tool for generating custom error messages and controlling the flow of your program. By understanding the key points and best practices of using throw , you can create more reliable and accurate code. By following the tips and syntax examples provided in this article, you can use throw to create better JavaScript programs.

Источник