Promise.resolve（）和resolve（）之间的区别？

Question

I wrote the code below:

function readFile(path) {
    return new Promise(function(resolve, reject){
        if(!fs.existsSync(path))
            return reject(new Error("data.json file does not exist"));
        else {
            console.log("File is actually found!");
            return Promise.resolve("File found");
        }
    })
}

readFile(path)
    .then(value => {
        console.log(value);
    })
    .catch(err => {
        console.log(err);
    })

What happens:
If the file exists, the console output is just File is actually found! If the file does not exist, it displays: data.json file does not exist along with the error stack.

What I want:
When the file does exist, I want File found to be displayed in addition to File is actually found! . I found that this happens when I replace return Promise.resolve("File found"); with just resolve("File found"); or even return resolve("File found"); .

Question:
What really is the difference between resolve() and Promise.resolve() ? Why does returning or not returning not make a difference (I guess it is because it is the last statement in the function).

Note: I use existsSync() because I want the process to be blocking until the file is actually read, because if the file is not read, then there is nothing to be done! I understand promise might not be needed here, but I still use it because that is what I am trying to learn.

Thanks!

Edit: One more question - what actually should be rejected and resolved? I mean, in the code above, I pass new Error(...) to reject() and a string to resolve() - is that alright?

Answer 1

Promise.resolve wraps an expression in a Promise. So Promise.resolve("File found"); is 'File found' wrapped in a Promise that resolves immediately.

Look at where the wrapped Promise is going in this code - you're returning it to the caller of the new Promise constructor. But the Promise constructor completely ignores a return value, if any. It's kind of like returning something when iterating in forEach - it just gets ignored.

In order to resolve a Promise constructed via the Promise constructor, you must call the first argument provided to the callback (which is conventionally named resolve , but may be named anything you want).

Also note that there's no need at all to wrap the rejection in new Error - if you just have a string message to send to the consumer, it's fine to reject with just a string.

function readFile(path) {
    return new Promise(function(resolve, reject){
        if(!fs.existsSync(path))
            reject("data.json file does not exist");
        else {
            console.log("File is actually found!");
            resolve("File found");
        }
    })
}

Which is equivalent to:

function readFile(path) {
    return new Promise((fnToCallToResolveConstructedPromise, fnToCallToRejectConstructedPromise) => {
        if(!fs.existsSync(path))
            fnToCallToRejectConstructedPromise("data.json file does not exist");
        else {
            console.log("File is actually found!");
            fnToCallToResolveConstructedPromise("File found");
        }
    })
}

You can wrap it in an error object if it provides useful info for you, aside from the string describing the error, but otherwise, best to omit it, and just call reject with a string.