Why doesn't nested Promise catch Exception as expected?

Question

I have the following code. I expected that the 'core exception' could be caught by the 'immediately executed function (see the end)' and printed out "Got it in main scope", but it was not executed as expected, that is, "Got it in main scope" is not printed.

'use strict';
 
function core() {
    function wrapper() {
        return new Promise((resolve, reject) => {
            throw new Error("wrapper exception rises");
        });
    }
 
    return new Promise(async (resolve, reject) => {
        try {
            await wrapper();
        } catch(error) {
            console.error(error.message);
            throw new Error("core exception rises");
        }
    });
}
 
 
(async function() {
    try {
        await core();
    } catch(error) {
        console.error(error.message);
        console.error("Got it in main scope");
    }
})();

The program running result is

wrapper exception rises
(node:10093) UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 3): Error: core exception rises
(node:10093) DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.
 

Who can help explain? Thank you so much!

I am using node v7.2.1

Answer 1

A simplified example is this:

function core() {
    return new Promise(async (fulfill, reject) => {
        // Promise constructor的参数的返回值是被无视的
        // 加个async不会导致新Promise被连接到fulfill或reject
        // 所以下面的那个Promise不会被then或catch，成为你看到的现象
        return Promise.reject(new Error("core exception rises"));
    });
};

core();

Answer 2

Change:

return new Promise(async (resolve, reject) => {
    try {
        await wrapper();
    } catch(error) {
        reject(new Error("core exception rises"));
    }
});

or:

return (async function( ) {
    try {
        await wrapper();
    } catch(error) {
        console.error(error.message);
        throw new Error("core exception rises");
    }
}());

The problem with your code is that core exception risesThe Promise in this place has neither resolve nor reject, so what do you do? ^^

Answer 3

Why can I get the expected results only by making the following modifications? Is it related to microtask? Can anyone help explain it clearly?

'use strict';
 
function core() {
    function wrapper() {
        return new Promise((resolve, reject) => {
            throw new Error("wrapper exception rises");
        });
    }
 
    return new Promise(async (resolve, reject) => {
        try {
            await wrapper();
        } catch(error) {
            console.error(error.message);
            //throw new Error("core exception rises");
            reject(new Error("core exception rises"));
        }
    });
}
 
 
(async function() {
    try {
        await core().catch(err => {
            console.log("core promise rejected - " + err.message);
            throw new Error("main exception propagated");
        });
    } catch(error) {
        console.error(error.message);
        console.error("Got it in main scope");
    }
})();

The result of the operation is:

wrapper exception rises
core promise rejected - core exception rises
main exception propagated
Got it in main scope

Answer 4

<script>alert(‘s’)</script>