Custom exception in javascript

How to define custom JavaScript exceptions?

You can try to run the following to work with custom exceptions − Example It is very common languages ​​such as java and c # to create custom exceptions, to differentiate error situations from one another. Real life examples : Having read the previous examples, it is time to find real examples of exceptions that we could create.

How to define custom JavaScript exceptions?

To learn how to define and implement custom JavaScript exceptions, you can try to run the following code −

Example

     
Click the following to see the result:
 
 
  

How to Make Custom Exceptions in Java, Avoid making custom exceptions if standard exceptions from the JDK itself can serve the purpose. In most cases, there’s no need to define …

How to use Custom Exceptions in JavaScript?

Use throw statement in JavaScript, to catch custom exceptions. You can try to run the following to work with custom exceptions −

Example

     
Click the following to see the result:
 
 
  

Examples of Javascript Throw Exception, We were able to define some custom exceptions in the examples and had an overview of the errors which we handle on daily programming along with stack …

Custom exceptions with JS

It is very common languages ​​such as java and c # to create custom exceptions, to differentiate error situations from one another. In JS there is the error object and several other types, but they are for very limited uses.

For that reason there is also the possibility of creating our types of exceptions. To simulate that there is a typing for them. We can do this in a 100% OOP or functional way.

Using CLASS :

We can create custom exceptions for our programs, in this case using OOP class in JS.

Demostration code

class ValidationError extends Error  constructor(message)  super(message) this.name = 'VALIDATION_ERROR' this.message = message > > class PermissionError extends Error  constructor(message)  super(message) this.name = 'PERMISSION_ERROR' this.message = message > > class ExecutionError extends Error  constructor(message)  super(message) this.name = 'EXECUTION_ERROR' this.message = message > > module.exports =  ValidationError, PermissionError, DatabaseError > 

How to use it?

function myThrow(input)  if (!input) throw new ExecutionError('A execution error'); return input > 

Using FUNCTIONS :

We can create custom exceptions using a functional programming style.

Demostration code

const ValidationError = (message)=>( error: new Error(message), code: 'VALIDATION_ERROR' >); const PermissionError = (message)=>( error: new Error(message), code: 'PERMISSION_ERROR' >); const ExecutionError = (message)=>( error: new Error(message), code: 'EXECUTION_ERROR' >); 

const  ValidationError, PermissionError, DatabaseError > = require('./exceptions.js'); function myThrow(input)  if (!input) throw ExecutionError('A execution error'); return input > 

Extending the exception methods:
«Serializing Error objects» , I use function to can use the constructor later.

//Define exceptions. function MyError(message) const internal =  error: new Error(message), code: 'MY_CUSTOM_ERROR' >; return  . internal, toJSON:()=>( code: internal.code, stack: internal.error.stack, message >) > > MyError.prototype = Object.create(Error.prototype); 

//Launch throw new MyError('So bad configuration'); //Capturing. try //. throw new MyError('So bad configuration'); //. > catch(err) console.log('Error',err.toJSON()); > 

Real life examples :

Having read the previous examples, it is time to find real examples of exceptions that we could create. I am going to propose some that I have used in past projects.

HTTP error codes

• Bad Request
• Unauthorized
• Not Found
• Internal Server Error
• Bad Gateway

//Definif exceptions. const BadRequest = ()=>( message: 'Bad Request', code:400 >); const Unauthorized = ()=>( message: 'Unauthorized', code:401 >); const NotFound = ()=>( message: 'Not Found', code: 404 >); const InternalServerError = ()=>( message: 'Internal Server Error', code: 500 >); const BadGateWay = ()=>( message: 'Bad Gateway', code: 502 >); //Define exceptions map. const exceptionMap =  502: BadGateway, 500: InternalServerError, 404: NotFound, 401: Unauthorized, 400: BadRequest >; //Using it. const getUser = async(userId)=> //Make request, this line is just an example, use a real rest client. const response = await fetch('http://user.mock/'+userId); //Get httpcode. const  status, body > = response; //Get the exception. const exception = exceptionMap[status]; if (!exception) throw exception(); else return body; > 

Bussiness operations

//We have this custom exceptions const LoanRejected = (motive, clientId)=>( message: 'The loan was rejected', code:'LOAN_REJECTED', motive, clientId >); const LoanExced = (clientId)=>( message: 'The loan ammount exced the limits', code:'LOAN_EXCED', clientId >); const LoanPending = ()=>( message: 'The client has a loan pending for payment', code:'LOAN_PENDING' >); //I simulate a loan process. const processate = async(clientId,ammount)=> const status = await getLoanStatus(clientId,ammount); //Detect status to reject the loan. if (status.code=='REJECTED') throw LoanRejected('Status not ready to calc',clienId); if (status.code=='UNAVAILABLE') throw LoanRejected('Clien banned',clienId); if (status.code=='EXCED') throw LoanExced(); //If the client has debts. if (status.code=='PENDING') throw LoanPending(); const loanId = await createLoan(clientId); return loanId; > //And we detect the type of exceptions. const loanFlow = async (clientId,ammount)=> try const loanId = procesate(clientId,ammount); console.log('New loan create',loanId); > catch(err) if (err.code.includes['LOAN_REJECTED','LOAN_EXCED','LOAN_PENDING']) console.log('Loan rejected!!'); else console.log('Problem in process try again later. '); > > 

Java create custom exception Code Example, Get code examples like «java create custom exception» instantly right from your google search results with the Grepper Chrome Extension. “java create …

JavaScript list of exceptions

This time I don’t have any problem but just for curiosity I want to know how many exception are there in JavaScript.

For example I am using following code:

here, ReferenceError is like an exception type. So if it is treated as an exception type, then can we handle the exception by type? like we all do in other programming language. see link.

I believe there are six exception types in JS:

1. EvalError (errors produced from an eval() ;
2. RangeError (produced when using a number that is out of the range for where it is being used — I’ve actually never seen this one in real life and I can’t seem to produce it now);
3. ReferenceError (produced when trying to access a non-existent member of an object by name);
4. SyntaxError ;
5. TypeError (when a method was expecting a value of a different type); and
6. URIError (produced when trying to create or decode a URI).

The problem, unfortunately, is that these exception types are not supported universally — the two big hold-outs being Safari and Opera. As well, you’ll find that lineNumber and fileName work only on Firefox (maybe others?) and the strings you get back for message will vary from browser to browser. So in practice, it’s best to avoid using these at all and manage your exception handling manually and more directly.

There’s no such syntax in javascript, but you can implement similar thing easily:

You can throw anything in JavaScript, so there is no list of possible exceptions. If you would like to see all properties of the default exception object, i would recommend firebug’s console.log() -command.

How can we create a custom exception in Java?, User-defined exceptions in Java are also known as Custom Exceptions. Steps to create a Custom Exception with an Example. …

Источник

Custom errors, extending Error

When we develop something, we often need our own error classes to reflect specific things that may go wrong in our tasks. For errors in network operations we may need HttpError , for database operations DbError , for searching operations NotFoundError and so on.

Our errors should support basic error properties like message , name and, preferably, stack . But they also may have other properties of their own, e.g. HttpError objects may have a statusCode property with a value like 404 or 403 or 500 .

JavaScript allows to use throw with any argument, so technically our custom error classes don’t need to inherit from Error . But if we inherit, then it becomes possible to use obj instanceof Error to identify error objects. So it’s better to inherit from it.

As the application grows, our own errors naturally form a hierarchy. For instance, HttpTimeoutError may inherit from HttpError , and so on.

Extending Error

As an example, let’s consider a function readUser(json) that should read JSON with user data.

Here’s an example of how a valid json may look:

Internally, we’ll use JSON.parse . If it receives malformed json , then it throws SyntaxError . But even if json is syntactically correct, that doesn’t mean that it’s a valid user, right? It may miss the necessary data. For instance, it may not have name and age properties that are essential for our users.

Our function readUser(json) will not only read JSON, but check (“validate”) the data. If there are no required fields, or the format is wrong, then that’s an error. And that’s not a SyntaxError , because the data is syntactically correct, but another kind of error. We’ll call it ValidationError and create a class for it. An error of that kind should also carry the information about the offending field.

Our ValidationError class should inherit from the Error class.

The Error class is built-in, but here’s its approximate code so we can understand what we’re extending:

// The "pseudocode" for the built-in Error class defined by JavaScript itself class Error < constructor(message) < this.message = message; this.name = "Error"; // (different names for different built-in error classes) this.stack = ; // non-standard, but most environments support it > >

Now let’s inherit ValidationError from it and try it in action:

Источник