Node.js 在链接的Promisified函数中创建MongoDB文档

应用程序每15分钟运行一个进程，创建以下格式的许多输出文件：

<timestamp>-<piece-code>.txt

在这个过程中，我想在创建时间戳之前找出它是否已经存在，以避免重复，但我的代码似乎无法做到这一点

提前感谢您的帮助

const mongoose = require('mongoose');

const Registry = require('../model/Registry');
const Piece = require('../model/Piece');
mongoose.Promise = require('bluebird');

// Set up default mongoose connection
let mongoDB = 'mongodb://127.0.0.1/numbers';
mongoose.connect(mongoDB, {
  useMongoClient: true
});

//Get the default connection
let db = mongoose.connection;

// Bind connection to error event
db.on('error', console.error.bind(console, 'MongoDB connection error:'));


// Error handler
let error = (err) => {
  console.log("** Error: ", err);
  db.close();
};

// Finish routine
let finish = () => {
    console.log("I have finished");
    db.close();
};


// Create a number if it does not exist already
let newRegistry = (timestamp) => {
  return new Promise((resolve, reject) => {
    Registry.count({}).then((c) => { console.log(c) })

    // Does this Registry exist?
    Registry.findOne({ time: timestamp })
      .then((reg, err) => {
        if (err) {
          reject(err);
        }
        // Create when it does not exist
        if (!reg) {
          Registry.create({
            time: timestamp
          }).then((doc, err) => {
            if (err) {
              reject(err);
            }
            resolve(doc._id);
          })
          .catch(error);
        } else {
          // Else, resolve
          resolve(reg._id);
        }

      });
  });
}

let newPiece = (registryId, filename, piece) => {
  return Piece.create({
    registry: mongoose.Types.ObjectId(registryId),
    file: filename,
    piece: piece
  });

};

let createRegs = (files) => {
  return new Promise((resolve, reject) => {
    let promises = [];
    let total = files.length;
    for (let i=0; i<total; i++) {
      let fileAr = files[i].split("-");
      let time = fileAr[0];
      let piece = fileAr[1];

      let promise = newRegistry(time)
        .then((regId) => {
          return newPiece(regId, files[i], piece);
        });

      promises.push(promise);
    }

    Promise.all(promises)
      .then(() => {
        resolve();
      })
      .catch(error);
  });
}


// Register input time and file pieces: one "time" can have many "pieces"
let filenames = ["1512473256-e.txt", "1512471758-a.txt", "1512471892-a.txt", "1512471758-b.txt"];

// Must end up with 3 "Registry" and 4 "Piece" documents
createRegs(filenames)
  .then(finish)
  .catch(error);

const mongoose=require（'mongoose'）；
const Registry=require（'../model/Registry'）；
const-Piece=require（“../model/Piece”）；
mongoose.Promise=require（'bluebird'）；
//设置默认mongoose连接
让mongoDBmongodb://127.0.0.1/numbers';
mongoose.connect（mongoDB{
useMongoClient：true
});
//获取默认连接
设db=mongoose.connection；
//将连接绑定到错误事件
db.on（'error'，console.error.bind（console，'MongoDB连接错误：'）；
//错误处理程序
让错误=（错误）=>{
日志（“**错误：”，err）；
db.close（）；
};
//完成例行程序
让我们结束=（）=>{
console.log（“我已经完成”）；
db.close（）；
};
//如果数字不存在，请创建一个数字
让newRegistry=（时间戳）=>{
返回新承诺（（解决、拒绝）=>{
Registry.count（{}）.then（（c）=>{console.log（c）}）
//这个注册表存在吗？
Registry.findOne（{time:timestamp}）
.然后（（注册，错误）=>{
如果（错误）{
拒绝（错误）；
}
//当它不存在时创建
如果（！reg）{
注册表。创建({
时间：时间戳
}).然后（（文件，错误）=>{
如果（错误）{
拒绝（错误）；
}
解决（文件编号）；
})
.捕捉（错误）；
}否则{
//否则，解决问题
解决（注册号）；
}
});
});
}
让newPiece=（registryId、文件名、piece）=>{
返回件。创建({
注册表：mongoose.Types.ObjectId（registryId），
文件名：，
件：件
});
};
让createRegs=（文件）=>{
返回新承诺（（解决、拒绝）=>{
让承诺=[]；
让total=files.length；
for（设i=0；i{
返回新件（regId，文件[i]，件）；
});
承诺。推动（承诺）；
}
所有（承诺）
.然后（（）=>{
解决（）；
})
.捕捉（错误）；
});
}
//注册输入时间和文件片段：一个“时间”可以有多个“片段”
让文件名=[“1512473256-e.txt”、“1512471758-a.txt”、“1512471892-a.txt”、“1512471758-b.txt”]；
//最后必须有3个“注册表”和4个“单件”文档
createRegs（文件名）
.然后（完成）
.捕捉（错误）；

是否值得避免在数组中重复数字？ 通过这样做：

let filtered = [];
numbers.forEach((num) => {
  // in case we don't have such entity creating it
  if (!filtered.includes(num)) {
    filtered.push(num);
  }
  // in case we have just returning resolved promise
  return Promise.resolve();
});

然后在DB中创建实体：

const promises = filtered.map(n => {
  Number.findOne({ number: n })
    .then(result => if(!result) {
      return Number.create({ number: n });
    }).catch(err => console.log(err));
});
Promise.all(promise).then(() => /* Doing what you want to do after saving */)

---

我的做法是：

首先，我要创建一个字典，其中键是时间戳，值是一个包含不同片段的数组

一旦你有了这本字典，我会处理列表中的每个时间戳

• 在数据库中查找时间戳。如果它还不存在，就创建它
• 循环遍历时间戳的所有部分并将其添加到数据库中

使用这种方法可以避免并发问题。

---

希望有帮助。

嗨。谢谢你的回复。好的，这只是一个例子，在真实情况下，数组是由forma

.txt中的文件名组成的，我需要为每个“时间戳”保存许多“代码”。哦，现在我知道了。尝试创建类似以下数字的代码。findOne（{Number:n}）.exec（）。然后（（result）=>/*这是检查它是否为空结果的代码*/）不，没有。每次“时间”都在数据库中创建，就好像它不存在一样。嗨。谢谢你的回复。好的，这只是一个例子，在实际情况下，数组是由forma
.txt中的文件名组成的，我需要在每个“时间戳”中保存许多“代码”。我不知道您编写的示例与您的问题有什么关系。也许最好用真实的问题和真实的代码创建另一个问题，以便更好地理解它。很抱歉没有再提供更多帮助了@David，我更新了问题，希望这更具体。谢谢你的建议。谢谢你的更新，现在一切都清楚了。我已经填好了我的答案，检查一下，告诉我你是否站得住脚。
const promises = filtered.map(n => {
  Number.findOne({ number: n })
    .then(result => if(!result) {
      return Number.create({ number: n });
    }).catch(err => console.log(err));
});
Promise.all(promise).then(() => /* Doing what you want to do after saving */)