Arrays Nodejs异步数据复制

我在nodejs上的一个异步进程中遇到了一些问题

我从一个远程JSON获取一些数据并将其添加到我的数组中，这个JSON有一些重复的值，我需要在添加之前检查它是否已经存在于我的数组中，以避免数据重复

我的问题是，当我启动JSON值之间的循环时，循环在最后一个值完成之前调用下一个值，因此，我的数组中填充了重复数据，而不是每个类型只维护一个项

查看我当前的代码：

BookRegistration.prototype.process_new_books_list = function(data, callback) {
    var i    = 0,
        self = this;
    _.each(data, function(book) {
      i++;
      console.log('\n\n ------------------------------------------------------------ \n\n');
      console.log('BOOK: ' + book.volumeInfo.title);
      self.process_author(book, function() { console.log('in author'); });
      console.log('\n\n ------------------------------------------------------------');
      if(i == data.length) callback();
    })
  }

BookRegistration.prototype.process_author = function(book, callback) {
  if(book.volumeInfo.authors) {
    var author = { name: book.volumeInfo.authors[0].toLowerCase() };
    if(!this.in_array(this.authors, author)) {
      this.authors.push(author);
      callback();
    }
  }
}

BookRegistration.prototype.in_array = function(list, obj) {
  for(i in list) { if(list[i] === obj) return true; }
  return false;
} 

结果是：

[{name: author1 }, {name: author2}, {name: author1}]

我需要：

[{name: author1 }, {name: author2}]

更新：

@Zub建议的解决方案适用于阵列，但不适用于sequelize和mysql数据库

当我试图在数据库中保存作者列表时，数据是重复的，因为系统在完成保存最后一个数组元素之前开始保存另一个数组元素

这个案子的正确模式是什么

我使用数据库的代码是：

BookRegistration.prototype.process_author = function(book, callback) {
  if(book.volumeInfo.authors) {
    var author = { name: book.volumeInfo.authors[0].toLowerCase() };
    var self   = this;
    models.Author.count({ where: { name: book.volumeInfo.authors[0].toLowerCase() }}).success(function(count) {
      if(count < 1) { 
        models.Author.create(author).success(function(author) {
          console.log('SALVANDO AUTHOR');
          self.process_publisher({ book:book, author:author }, callback);
        });
      } else {
        models.Author.find({where: { name: book.volumeInfo.authors[0].toLowerCase() }}).success(function(author) {
          console.log('FIND AUTHOR');
          self.process_publisher({ book:book, author:author }, callback);
        });        
      }
    });
    // if(!this.in_array(this.authors, 'name', author)) {
    //   this.authors.push(author);
    //   console.log('AQUI NO AUTHOR');
    //   this.process_publisher(book, callback);
    // }
  }
}

BookRegistration.prototype.process\u author=函数（book，回调）{
if（book.volumeInfo.authors）{
var author={name:book.volumeInfo.authors[0].toLowerCase（）}；
var self=这个；
models.Author.count（{where:{name:book.volumeInfo.authors[0].toLowerCase（）}）.success（函数（count）{
如果（计数<1）{
models.Author.create（Author）.success（函数（Author）{
console.log（'SALVANDO AUTHOR'）；
self.process_publisher（{book:book，author:author}，回调）；
});
}否则{
models.Author.find（{where:{name:book.volumeInfo.authors[0].toLowerCase（）}）.success（函数（Author）{
log（'FIND AUTHOR'）；
self.process_publisher（{book:book，author:author}，回调）；
});        
}
});
//if（！this.in_数组（this.authors，'name'，author））{
//this.authors.push（author）；
//log（'AQUI NO AUTHOR'）；
//此.process_publisher（book，callback）；
// }
}
}

---

如何避免异步进程中的数据重复？

这是因为您正在比较不同的对象，结果总是

false

仅针对控制台中的实验类型：

var obj1 = {a:1};
var obj2 = {a:1};
obj1 == obj2;    //false

比较对象（以及数组）时，只有当

obj1

链接到

obj2

时，才会产生

true

：

var obj1 = {a:1};
var obj2 = obj1;
obj1 == obj2;    //true

由于您在每个

过程中创建了新的
author
对象\u author

调用，因此在比较时总是会得到

false

在您的情况下，解决方案是比较每本书的

name

属性：

BookRegistration.prototype.in_array = function(list, obj) {
  for(i in list) { if(list[i].name === obj.name) return true; }
  return false;
}

编辑（与您的评论问题相关）：

我将重写

process\u new\u books\u list

方法如下：

BookRegistration.prototype.process_new_books_list = function(data, callback) {
    var i = 0,
        self = this;
    (function nextBook() {
        var book = data[i];
        if (!book) {
            callback();
            return;
        }
        self.process_author(book, function() {
            i++;
            nextBook();
        });
    })();
}

在这种情况下，下一个

process\u author

不会立即被调用（就像

\u.each

），而是在执行回调之后被调用，因此您在程序中会产生后果

但不确定这是否有效

---

对不起，我的英语不是以英语为母语的人

嗨，这很好，但是现在，我有另一个相关的问题，当我使用数据库执行相同的过程时，数据是重复的。我认为这是因为数据库进程的延迟更大，循环在finishi处理最后一个作者之前开始处理一个新作者。我使用数据库用代码更新我的问题。你能看一下吗？