Capturing Mistakes in Promises Using Async/Await

Question

Capturing Mistakes in Promises Using Async/Await

I'm running into an issue where I need to handle errors within a promise using async/await, but the current code keeps resulting in an "Uncaught Error ..."

function makeMistake() {
    var promise = new Promise(function(resolve, reject){
        setTimeout(function() {
            throw new Error("Oops! An error occurred.");
            resolve('Hello from makeMistake function');
        }, 1000);
    });
    return promise;
}

async function waitForError() {
    try {
        await makeMistake();
    } catch(e) {
        console.log ('*****Successfully caught the error! *****');
    }
}

waitForError()

javascript promise async-await

Answer 1

Answer №1

The error is being triggered within the setTimeout function, not from a promise callback. Since timer callbacks like this are asynchronous, any errors thrown will not be caught and will likely be displayed in the browser console.

To reject the promise you've created, make sure to use the reject method:

function troubleshoot() {
    var promise = new Promise(function(resolve, reject){
        setTimeout(function() {
            reject(new Error("Error thrown from troubleshoot()"));
            resolve('Greetings from troubleshoot function'); // This line serves no purpose now
        }, 1000);
    });
    return promise;
}

If you want to handle any synchronous errors inside the timer callback and pass them to reject, you can utilize try/catch:

function troubleshoot() {
    var promise = new Promise(function(resolve, reject){
        setTimeout(function() {
            try {
                throw new Error("Error thrown from troubleshoot()");
                resolve('Greetings from troubleshoot function'); // This line will never execute
            } catch (e) {
                reject(e);
            }
        }, 1000);
    });
    return promise;
}

Answer 2

The error is being triggered within the setTimeout function, not from a promise callback. Since timer callbacks like this are asynchronous, any errors thrown will not be caught and will likely be displayed in the browser console.

To reject the promise you've created, make sure to use the reject method:

function troubleshoot() {
    var promise = new Promise(function(resolve, reject){
        setTimeout(function() {
            reject(new Error("Error thrown from troubleshoot()"));
            resolve('Greetings from troubleshoot function'); // This line serves no purpose now
        }, 1000);
    });
    return promise;
}

If you want to handle any synchronous errors inside the timer callback and pass them to reject, you can utilize try/catch:

function troubleshoot() {
    var promise = new Promise(function(resolve, reject){
        setTimeout(function() {
            try {
                throw new Error("Error thrown from troubleshoot()");
                resolve('Greetings from troubleshoot function'); // This line will never execute
            } catch (e) {
                reject(e);
            }
        }, 1000);
    });
    return promise;
}

Answer 3

Answer №2

When using a try-catch block in conjunction with the await keyword, it specifically checks for the promise to either be fulfilled or rejected.

If you reject the promise and throw an error that is not related to the resolution of the promise (as you are currently doing), then it will be caught by your existing setup.

It's important to note that the error being thrown currently has no connection to the asynchronous operation being executed.

function messup() {
    var promise = new Promise(function(resolve, reject){
        setTimeout(function() {
            reject("Thrown from messup()"); //<-- do this instead
        }, 1000);
    });
    return promise;
}

To delve deeper into this topic, check out my exploration of async/await error handling in this detailed guide on async/await.

Answer 4

When using a try-catch block in conjunction with the await keyword, it specifically checks for the promise to either be fulfilled or rejected.

If you reject the promise and throw an error that is not related to the resolution of the promise (as you are currently doing), then it will be caught by your existing setup.

It's important to note that the error being thrown currently has no connection to the asynchronous operation being executed.

function messup() {
    var promise = new Promise(function(resolve, reject){
        setTimeout(function() {
            reject("Thrown from messup()"); //<-- do this instead
        }, 1000);
    });
    return promise;
}

To delve deeper into this topic, check out my exploration of async/await error handling in this detailed guide on async/await.

Capturing Mistakes in Promises Using Async/Await

Answer №1

Answer №2

Similar questions

Chai-http does not execute async functions on the server during testing

Error: Unable to access the 'wsname' property of an undefined value

Tips for creating a POST request using mongoose in NextJS version 13.4

Generating dynamic forms using JSON Schema in Angular 8 can greatly streamline the form creation process

Creating Sliding Panels: A Step-by-Step Guide

Guide on creating a dynamic slideshow viewer

Repeatedly utilizing a drop-down menu

Tips for assigning a class name to a variable element within a react component?

The functionality of submitting an Ajax form is only successful on Firefox browser

When the AJAX function is called again, the previous loading process is interrupted, without the use of jQuery

Can someone explain the intention behind using the code snippet {...rest}? I already understand how the three dots spread notation works in React Javascript

Simultaneous appearance of multiple jQuery dialogs

Encountering an error in Express while attempting to upload an image due to the inability to read the property 'file' of undefined

What is the best way to format the incoming data to display as HTML code?

What could be causing the Babel installation to fail within Electron? Is Babel necessary for my project or can it be avoided?

Strategies for resolving a mix of different data types within a single parameter

MongooseError: The operation `users.findOne()` has encountered an issue

Using the jQuery unbind method allows the function to execute only once, however, the event will not be

stop harmful code written in javascript from running

Is it feasible to impersonate a session in PHP by manipulating cookies on the client-side with JavaScript?