Javascript 在一系列promise.then.then链期间，需要从创建模型的文件中创建mongoose模型。

不，你不是我妻子，但我最近和你在一起的时间确实比她多

无论如何，我正在将一个php站点转换为node.js，并且已经掌握了创建mongoose模式和模型的诀窍。唯一奇怪的是，您需要模型能够对数据库执行任何查询

所以我一直是var etc=require（“./models/etc”）；'正在为我的index.js服务器中的app.get请求设置要使用的模型。I model.find我想要的数据并将其传递给jade/pug模板渲染

这还可以，因为在我所有的模型文件中，我都是手工创建模式的，也就是说：我编写对象，然后用它创建一个模型，然后用这些模式创建文档并保存它们

但是，现在我有了一个产品模式/对象，它依赖于从shopify api获取产品，使用节点模块generate schema从该产品创建模式，然后创建模型，然后从shopify循环产品，为每个文档创建一个新文档，并附加一些图像URL和一些其他属性，然后保存文档

这一切都发生在一系列的.then（function（））中，其中一个objects对象通过整个链并存储每个函数所需的所有变量。然后在承诺链的末尾，我尝试module.exports=objects.variable（在本例中，它是一个mongoose模型）。但因为在index.js中，当I var product=require（'./models/products'）时，它会异步执行此操作，因此变量product只是{}，而不是等待.then承诺链出现，然后使用最后写入的module.exports

是否有办法使require（x）等待module.exports被填充，或者在分配变量之前等待整个文件已经运行

多谢各位

这是你需要的代码

var MongoClient = require('mongodb');

// mongodb = MongoClient.connect('mongodb://localhost/myleisure');

var mongoose = require('mongoose');

var fs = require('fs');
var path = require('path');

var generateSchema = require('generate-schema');

// mongoose.connect("mongodb://localhost/myleisure");
//
// var db = mongoose.connection;

var Schema = mongoose.Schema;


var shopify = require('shopify-buy');

var client = shopify.buildClient({
  accessToken: 'private',
  domain: 'my-leisure.myshopify.com',
  appId: 'X'
});




var write = true;

//Only uncomment if you want to export hell
// module.exports = function (callback) {

client.fetchProduct('8461073805').then(function(products) {
  var objects = {};

  objects.schema = generateSchema.mongoose(products.attrs.variants[0]);
  objects.products = products;

  return objects;

})
.then(function(objects){

  var productSchema = new Schema(objects.schema);

  productSchema.add({
    images: {type: [], default: null},
    thumbnail: {type: String, default: "thumb.jpg"},
    name: {type: String, default: "lettini"},
    colour: {type: String, default: null},
    finish: {type: String, default: null},
    size: {type: String, default: null},
    id: {type: String, default: objects.products.attrs.product_id},
    variantId: {type: String, default: null}
  });

  var product = mongoose.model("product", productSchema);


  product.remove({});
  objects.product = product;
  // callback(product)
  return objects;

}).then(function(objects){

  if(write)
    return objects.product.remove({name: "lettini"}).then(function(){

      return objects
    });

}).then(function(objects){
  if(write)
    var productsDir = "./img/products/lettinis/400x";
    var products = objects.products;
    var product = objects.product;
    // console.log(products.variants.length);
    // console.log(i);

    // console.log(schema);
    // console.log(products.attrs.variants);

    fs.readdir(productsDir, (err, skus) => {
      skus.forEach(sku => {
        for (var i = 0; i < products.variants.length - 1; i++) {
          if ( products.variants[i].attrs.variant.sku === sku) {

            var tempProduct = products.variants[i].attrs.variant;
            var newProduct = new product(tempProduct);

            fs.readdir(productsDir + "/" + sku, (err, images) => {
              images.forEach(image => {
                newProduct.colour = tempProduct.option_values[1].value;
                newProduct.frame = tempProduct.option_values[2].value;
                newProduct.size = tempProduct.option_values[0].value;
                newProduct.images.push(image);
              });
              newProduct.save();
            });

          };
        };
      });
    });

    return objects

}).then(function(objects){
  // console.log(objects.product);
  module.exports = objects.product;
});

输出：

{}

然后在承诺链的末尾，我尝试

module.exports=objects.variable

（在本例中，它是一个mongoose模型）。但它是异步的

不要异步导出某些内容。改为导出承诺-立即：

module.exports = client.fetchProduct(…).then(…)
.…
.then(function(objects){
  // console.log(objects.product);
  return objects.product;
});

因此，您可以使用promise技术（也可以是

promise.all

，以防加载更多模块）在index.js中等待它：

require('./models/products').then(function(product) {
  console.log(product);
});

---

您应该导出承诺本身，并使用

require（'./models/products'）。然后（console.log）

@bergi，但mongoose模型应该在应用程序的整个生命周期内保存，而不仅仅是在承诺线程中保存。您所说的“承诺线程”是什么意思？promise值在应用程序的整个生命周期内都存储在模块注册表中。是的，但您不会将其用作require（“./models/products”）。然后（x）您将使用var x=require（“./models/products”）；然后在应用程序的后面，转到x。然后（等…）对吗？它看起来是require（x）。然后不是一个函数？但在应用程序中，我需要在多个位置运行导出，而不仅仅是在require（“”）之后，而且我也不希望在需要使用模块的每个实例上都运行require？导出不是“运行”，而是使用的。是的，你需要在你需要模块的任何地方都需要它，但这与它是一个承诺无关。它是一个承诺，承诺不会突然改变它的身份为结果值<代码>然后是代码始终工作所必需的，即使

查找

仍在执行。是否有一个承诺或变量的版本，它以具体的形式设置自己，比如var thing=new promise；var thing=thing.then（函数（承诺）{返回承诺}）；如果你明白我的意思？谢谢你的帮助，这正是我所需要的。谢谢不，你不能-这意味着你（可能）在它可用之前就可以访问它。只需做

promise.then（function（thing）{/*使用thing的整个模块*/}）
require('./models/products').then(function(product) {
  console.log(product);
});