javascript - NodeJS, JS how to export Promise value in a module, not the function? - Stack Overflow

admin管理员组

文章数量:1130349

Let's say I want to export in a single JS module some value which is obtained by calling some async function. What is the mechanism to make the export wait for the result/Promise to be resolved?

As an example code snippet I put this here

function go() {
  return new Promise((resolve, reject) => {
    setTimeout(() => resolve("Success!"), 3000);
  });
}

let AS;
go().then((x) => {
  AS = x;
});
module.exports = AS;

This function could make any API request. I don't want to export the entire function and call it in other module.

Let's say I want to export in a single JS module some value which is obtained by calling some async function. What is the mechanism to make the export wait for the result/Promise to be resolved?

As an example code snippet I put this here

function go() {
  return new Promise((resolve, reject) => {
    setTimeout(() => resolve("Success!"), 3000);
  });
}

let AS;
go().then((x) => {
  AS = x;
});
module.exports = AS;

This function could make any API request. I don't want to export the entire function and call it in other module.

• javascript
• node.js
• asynchronous
• export

Share Improve this question Follow edited Jun 27, 2020 at 9:01 Tigran Sahakyan asked Jun 27, 2020 at 8:53 Tigran SahakyanTigran Sahakyan 42511 gold badge66 silver badges1010 bronze badges

Add a ment  | 

1 Answer 1

Sorted by: Reset to default 8

Two answers for you:

• With standard JavaScript modules (ESM)
• With CommonJS (CJS), the module system you're using in the example in the question

With Standard JavaScript Modules (ESM)

Now that support for ESM has matured, in most Node.js projects you can switch to ESM from CommonJS by putting "type": "module" in your package.json and changing your require() calls to import statements as necessary. If you can do that, you can use top-level await. With top-level await, you can make your module execution wait for a promise to settle (which makes modules that import from your module wait until the promise settles). So you'd do this:

function go() {
    return new Promise((resolve, reject) => {
        setTimeout(() => resolve("Success!"), 500);
    });
}

export const AS = await go();

That exports a named export, but you could also replace that last line with this to do a default export (which is more similar to what you have in your CommonJS code; I prefer to avoid default exports):

export default await go();

Modules using your module don't have to be aware of the fact that the value es from an asynchronous source; they aren't evaluated until your module evaluation has finished (after the promise settles). They just import as usual:

import { AS } from "./promise.js"; // If it's a named export
// import AS from "./promise.js";  // If it's the default export
console.log("AS = " + AS);

With CommonJS (CJS)

With CommonJS, your best bet is to export the promise. That way, code using your module has a standard way to handle the fact that the value may not be available yet — Consuming the promise:

require("./your-moudule")
.then(AS => {
    // ...use `AS` here...
})
.catch(error => {
    // ...handle the fact we didn't get it here...
});

But if you want to export the value instead, you can, it's just usually not your best approach. You'd do that by exporting an object and then updating its AS property:

function go() {
    return new Promise((resolve, reject) => {
        setTimeout(() => resolve("Success!"), 500);
    });
}

module.exports = {AS: undefined};
go().then((x) => {
    module.exports.AS = x;
});

Modules using your module would have to deal with the fact that briefly (probably) during process startup, they'll be getting undefined. Here's code using the module above:

const mod = require("./promise"); // Note: Not destructuring at this point
const timer = setInterval(() => {
    const { AS } = mod;
    console.log("AS = " + AS);
    if (AS) {
        clearInterval(timer);
    }
}, 100);

If you run that, you'll see AS = undefined ~5 times and then AS = Success!.

In both cases, it makes the code using your module more plex (they have to await the promise or loop when they see undefined). ESM's approach is simpler from that perspective (those modules just don't run until your module is ready).

Let's say I want to export in a single JS module some value which is obtained by calling some async function. What is the mechanism to make the export wait for the result/Promise to be resolved?

As an example code snippet I put this here

function go() {
  return new Promise((resolve, reject) => {
    setTimeout(() => resolve("Success!"), 3000);
  });
}

let AS;
go().then((x) => {
  AS = x;
});
module.exports = AS;

This function could make any API request. I don't want to export the entire function and call it in other module.

Let's say I want to export in a single JS module some value which is obtained by calling some async function. What is the mechanism to make the export wait for the result/Promise to be resolved?

As an example code snippet I put this here

function go() {
  return new Promise((resolve, reject) => {
    setTimeout(() => resolve("Success!"), 3000);
  });
}

let AS;
go().then((x) => {
  AS = x;
});
module.exports = AS;

This function could make any API request. I don't want to export the entire function and call it in other module.

• javascript
• node.js
• asynchronous
• export

Share Improve this question Follow edited Jun 27, 2020 at 9:01 Tigran Sahakyan asked Jun 27, 2020 at 8:53 Tigran SahakyanTigran Sahakyan 42511 gold badge66 silver badges1010 bronze badges

Add a ment  | 

1 Answer 1

Sorted by: Reset to default 8

Two answers for you:

• With standard JavaScript modules (ESM)
• With CommonJS (CJS), the module system you're using in the example in the question

With Standard JavaScript Modules (ESM)

Now that support for ESM has matured, in most Node.js projects you can switch to ESM from CommonJS by putting "type": "module" in your package.json and changing your require() calls to import statements as necessary. If you can do that, you can use top-level await. With top-level await, you can make your module execution wait for a promise to settle (which makes modules that import from your module wait until the promise settles). So you'd do this:

function go() {
    return new Promise((resolve, reject) => {
        setTimeout(() => resolve("Success!"), 500);
    });
}

export const AS = await go();

That exports a named export, but you could also replace that last line with this to do a default export (which is more similar to what you have in your CommonJS code; I prefer to avoid default exports):

export default await go();

Modules using your module don't have to be aware of the fact that the value es from an asynchronous source; they aren't evaluated until your module evaluation has finished (after the promise settles). They just import as usual:

import { AS } from "./promise.js"; // If it's a named export
// import AS from "./promise.js";  // If it's the default export
console.log("AS = " + AS);

With CommonJS (CJS)

With CommonJS, your best bet is to export the promise. That way, code using your module has a standard way to handle the fact that the value may not be available yet — Consuming the promise:

require("./your-moudule")
.then(AS => {
    // ...use `AS` here...
})
.catch(error => {
    // ...handle the fact we didn't get it here...
});

But if you want to export the value instead, you can, it's just usually not your best approach. You'd do that by exporting an object and then updating its AS property:

function go() {
    return new Promise((resolve, reject) => {
        setTimeout(() => resolve("Success!"), 500);
    });
}

module.exports = {AS: undefined};
go().then((x) => {
    module.exports.AS = x;
});

Modules using your module would have to deal with the fact that briefly (probably) during process startup, they'll be getting undefined. Here's code using the module above:

const mod = require("./promise"); // Note: Not destructuring at this point
const timer = setInterval(() => {
    const { AS } = mod;
    console.log("AS = " + AS);
    if (AS) {
        clearInterval(timer);
    }
}, 100);

If you run that, you'll see AS = undefined ~5 times and then AS = Success!.

In both cases, it makes the code using your module more plex (they have to await the promise or loop when they see undefined). ESM's approach is simpler from that perspective (those modules just don't run until your module is ready).

本文标签：