Javascript，两个async / await和promise func，但是一个正在工作，另一个不在工作

Question

my utils.js have two funcs. i using in the electron@2.0.2.

async function detectMimeType(filePath) {
    let detectMime=new Promise((resolve, reject) => {
          // mmmagic npm module
          magic.detectFile(filePath, function(err, result) {
               if (err) reject(err);
               resolve(result);
          });
    });

    let result = await detectMime;

    return result;
}

async function parseXML(data) {
    let parse = new Promise((resolve, reject) => {
        // xml2js npm module
        parser.parseString(data,function(err,xmldata){
            if (err) reject(err);
            resolve(xmldata);
        });
    });

    let result = await parse;

    return result;
}

detectMimeType func returning result. but parseXML func returning Promise object pending.

let mime = detectMimeType('testingSound.mp3'); // returning 'audio/mpeg';
let xmlPayload = 
    parseXML('<root><test>testData</test></root>'); //returning Promise object pending

but it works like this.

async function init(){
    let xmlPayload = 
    await parseXML('<root><test>testData</test></root>');
}

Why does not it work like detectMimeType?

UPDATE: detectMimeType and parseXML two func returning Promise Object. async functions always return a Promise.

Answer 1

Functions declared as async function always return promises, even if their body is completely synchronous:

async function foo() {
    // seemingly synchronous code
    return "bar!";
}

const a = foo(); // Promise<pending>
const b = await foo(); // "bar!"

Whatever you return from the async function, is passed to the either resolve() or reject() function of the implicit promise that has been created as the result of async function invocation.

So, you have always await foo() for the result, or use foo().then() if you are forced to use callbacks.

In general case, return await promise is merely a self-documentating construct, effectively equivalent to return promise , because promise would be in any case awaited as part of the implicit return promise resolve process.

Also, given your intent, I'd suggest promisifying your functions using standard Node.js util.promisify or Bluebird.promisify (whichever is available to you):

const { promisify } = require('util');

const detectMimeType = promisify(magic.detectFile);
const parseXML = promisify(parser.parseString);

This keeps them functionally equivalent to the code you have produced already, but restraints from excessive use of new Promise() , generally frowned upon.