blocks|key|498134|text|这里有一个基于计数方法的潜在解决方案(我还没有测试过它，也没有错误陷阱，但它应该传达了这个想法)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|498135|基本策略是:获取需要更新的记录数，异步保存每条记录，并在成功时进行回调，如果计数达到0(最后一次更新完成时)，将递减计数并关闭DB。通过使用{safe:true}，我们可以确保每次更新都是成功的。|offset|length|style|CODE|498136|mongo服务器将为每个连接使用一个线程，因此最好是a)关闭未使用的连接，或者b)将它们池化/重用。|498137|db.open(function+(err,+db)+{
++db.collection('foo',+function+(err,+collection)+{
++++var+cursor+=+collection.find({});
++++cursor.count(function(err,count)){
++++++var+savesPending+=+count;

++++++if(count+==+0){
++++++++db.close();
++++++++return;
++++++}

++++++var+saveFinished+=+function(){
++++++++savesPending--;
++++++++if(savesPending+==+0){
++++++++++db.close();
++++++++}
++++++}

++++++cursor.each(function+(err,+doc)+{
++++++++if+(doc+!=+null)+{
++++++++++doc.newkey+=+'foo';+//+Make+some+changes
++++++++++db.save(doc,+{safe:true},+saveFinished);
++++++++}
++++++});
++++})
++});
});|code-block|syntax|javascript|498138|entityMap^0|0|1Y|B|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|U|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|V|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Here's a potential solution based on the counting approach (I haven't tested it and there's no error trapping, but it should convey the idea).

The basic strategy is: Acquire the count of how many records need to be updated, save each record asynchronously and a callback on success, which will decrement the count and close the DB if the count reaches 0 (when the last update finishes). By using <code>{safe:true}</code> we can ensure that each update is successful.

The mongo server will use one thread per connection, so it's good to either a) close unused connections, or b) pool/reuse them.

<pre><code>db.open(function (err, db) {
 db.collection('foo', function (err, collection) {
 var cursor = collection.find({});
 cursor.count(function(err,count)){
 var savesPending = count;

 if(count == 0){
 db.close();
 return;
 }

 var saveFinished = function(){
 savesPending--;
 if(savesPending == 0){
 db.close();
 }
 }

 cursor.each(function (err, doc) {
 if (doc != null) {
 doc.newkey = 'foo'; // Make some changes
 db.save(doc, {safe:true}, saveFinished);
 }
 });
 })
 });
});
</code></pre>

blocks|key|498177|text|我发现使用计数器可能适用于简单的场景，但在复杂的场景中可能很难。这是我提出的一个解决方案，当数据库连接空闲时关闭数据库连接：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|498178|var+dbQueryCounter+=+0;
var+maxDbIdleTime+=+5000;+//maximum+db+idle+time

var+closeIdleDb+=+function(connection){
++var+previousCounter+=+0;
++var+checker+=+setInterval(function(){
++++if+(previousCounter+==+dbQueryCounter+&&+dbQueryCounter+!=+0)+{
++++++++connection.close();
++++++++clearInterval(closeIdleDb);
++++}+else+{
++++++++previousCounter+=+dbQueryCounter;
++++}
++},+maxDbIdleTime);
};

MongoClient.connect("mongodb://127.0.0.1:27017/testdb",+function(err,+connection)(
++if+(err)+throw+err;
++connection.collection("mycollection").find({'a':{'$gt':1}}).toArray(function(err,+docs)+{
++++dbQueryCounter+%2B%2B;
++});+++
++//do+any+db+query,+and+increase+the+dbQueryCounter
++closeIdleDb(connection);
));|code-block|syntax|javascript|498179|这可以是任何数据库连接的通用解决方案。maxDbIdleTime可以设置为与数据库查询超时相同的值或更长的值。|498180|这不是很优雅，但我想不出更好的方法来做到这一点。我使用NodeJs运行一个查询MongoDb和Mysql的脚本，如果数据库连接没有正确关闭，该脚本将永远挂起。|498181|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I found that using counter may apply to simple scenario, but may be hard in complicated situations. Here is a solution that I come up by closing the database connection when database connection is idle:

<pre><code>var dbQueryCounter = 0;
var maxDbIdleTime = 5000; //maximum db idle time

var closeIdleDb = function(connection){
 var previousCounter = 0;
 var checker = setInterval(function(){
 if (previousCounter == dbQueryCounter &amp;&amp; dbQueryCounter != 0) {
 connection.close();
 clearInterval(closeIdleDb);
 } else {
 previousCounter = dbQueryCounter;
 }
 }, maxDbIdleTime);
};

MongoClient.connect("mongodb://127.0.0.1:27017/testdb", function(err, connection)(
 if (err) throw err;
 connection.collection("mycollection").find({'a':{'$gt':1}}).toArray(function(err, docs) {
 dbQueryCounter ++;
 }); 
 //do any db query, and increase the dbQueryCounter
 closeIdleDb(connection);
));
</code></pre>

This can be a general solution for any database Connections. maxDbIdleTime can be set as the same value as db query timeout or longer.

This is not very elegant, but I can't think of a better way to do this. I use NodeJs to run a script that queries MongoDb and Mysql, and the script hangs there forever if the database connections are not closed properly.

blocks|key|498213|text|我想出了一个解决方案，其中包括一个像这样的计数器。它不依赖于count()调用，也不等待超时。它将在每个()中的所有文档耗尽后关闭db。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|498214|var+mydb+=+{};+//+initialize+the+helper+object.

mydb.cnt+=+{};+//+init+counter+to+permit+multiple+db+objects.

mydb.open+=+function(db)+//+call+open+to+inc+the+counter.
{
++if(+!mydb.cnt[db.tag]+)+mydb.cnt[db.tag]+=+1;
++else+mydb.cnt[db.tag]%2B%2B;
};+

mydb.close+=+function(db)+//+close+the+db+when+the+cnt+reaches+0.
{
++mydb.cnt[db.tag]--;
++if+(+mydb.cnt[db.tag]+<=+0+)+{
++++delete+mydb.cnt[db.tag];
++++return+db.close();
++}
++return+null;
};|code-block|syntax|javascript|498215|因此，每次您要调用db.each()或db.save()时，您将使用这些方法来确保数据库在工作时准备就绪，并在完成时关闭。|498216|来自OP的示例：|498217|foo+=+db.collection('foo');

mydb.open(db);+//+***+Add+here+to+init+the+counter.**++
foo.find({},function(err,cursor)
{
++if(+err+)+throw+err;+
++cursor.each(function+(err,+doc)
++{
++++if(+err+)+throw+err;
++++if+(doc+!=+null)+{
++++++doc.newkey+=+'foo';
++++++mydb.open(db);+//+***+Add+here+to+prevent+from+closing+prematurely+**
++++++foo.save(doc,+function(err,count)+{
++++++++if(+err+)+throw+err;
++++++++mydb.close(db);+//+***+Add+here+to+close+when+done.+**
++++++});+
++++}+else+{
++++++mydb.close(db);+//+***+Close+like+this+instead.+**
++++}
++});
});|498218|现在，假设来自每个的倒数第二个回调在每个回调的最后一个回调转到mydb.close()之前通过mydb.open()完成。所以，当然，如果这是一个问题，请让我知道。|498219|因此:将mydb.open(+db+)放在db调用之前，并将mydb.close(db)放在回调的返回点或db调用之后(取决于调用类型)。|498220|在我看来，这种计数器应该在db对象中维护，但这是我目前的变通方法。也许我们可以创建一个新的对象，在构造函数中接受一个db，并包装mongodb函数以更好地处理close。|498221|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

I came up with a solution that involves a counter like this. It does not depend on a count() call nor does it wait for a time out. It will close the db after all the documents in each() are exhausted. 

<pre><code>var mydb = {}; // initialize the helper object.

mydb.cnt = {}; // init counter to permit multiple db objects.

mydb.open = function(db) // call open to inc the counter.
{
 if( !mydb.cnt[db.tag] ) mydb.cnt[db.tag] = 1;
 else mydb.cnt[db.tag]++;
}; 

mydb.close = function(db) // close the db when the cnt reaches 0.
{
 mydb.cnt[db.tag]--;
 if ( mydb.cnt[db.tag] &lt;= 0 ) {
 delete mydb.cnt[db.tag];
 return db.close();
 }
 return null;
};
</code></pre>

So that each time you are going to make a call like db.each() or db.save() you would use these methods to ensure the db is ready while working and closed when done.

Example from OP:

<pre><code>foo = db.collection('foo');

mydb.open(db); // *** Add here to init the counter.** 
foo.find({},function(err,cursor)
{
 if( err ) throw err; 
 cursor.each(function (err, doc)
 {
 if( err ) throw err;
 if (doc != null) {
 doc.newkey = 'foo';
 mydb.open(db); // *** Add here to prevent from closing prematurely **
 foo.save(doc, function(err,count) {
 if( err ) throw err;
 mydb.close(db); // *** Add here to close when done. **
 }); 
 } else {
 mydb.close(db); // *** Close like this instead. **
 }
 });
});
</code></pre>

Now, this assumes that the second to last callback from each makes it through the mydb.open() before the last callback from each goes to mydb.close().... so, of course, let me know if this is an issue.

So: put a mydb.open(db) before a db call and put a mydb.close(db) at the return point of the callback or after the db call (depending on the call type).

Seems to me that this kind of counter should be maintained within the db object but this is my current workaround. Maybe we could create a new object that takes a db in the constructor and wrap the mongodb functions to handle the close better.

blocks|key|713739|text|最好使用池连接，然后在应用程序生命周期结束时在清理函数中调用db.close()：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|713740|process.on('SIGINT',+cleanup);
process.on('SIGTERM',+cleanup);|code-block|syntax|javascript|713741|请参阅http://mongodb.github.io/node-mongodb-native/driver-articles/mongoclient.html|offset|length|713742|有点旧的线程，但不管怎样。|713743|entityMap|0|LINK|mutability|MUTABLE|url|http://mongodb.github.io/node-mongodb-native/driver-articles/mongoclient.html^0|0|0|3|25|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@$I|X|J|Y|1|Z]]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

It's best to use a pooled connection and then call db.close() in cleanup function at the end of your application's life:

<pre><code>process.on('SIGINT', cleanup);
process.on('SIGTERM', cleanup);
</code></pre>

See <a href="http://mongodb.github.io/node-mongodb-native/driver-articles/mongoclient.html" rel="noreferrer">http://mongodb.github.io/node-mongodb-native/driver-articles/mongoclient.html</a>

A bit old thread, but anyway.

blocks|key|498292|text|基于上面@mpobrien的建议，我发现async模块在这方面非常有帮助。下面是我采用的一个示例模式：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|498293|const+assert+=+require('assert');
const+async+=+require('async');
const+MongoClient+=+require('mongodb').MongoClient;

var+mongodb;

async.series(
++++[
++++++++//+Establish+Covalent+Analytics+MongoDB+connection
++++++++(callback)+=>+{
++++++++++++MongoClient.connect('mongodb://localhost:27017/test',+(err,+db)+=>+{
++++++++++++++++assert.equal(err,+null);
++++++++++++++++mongodb+=+db;
++++++++++++++++callback(null);
++++++++++++});
++++++++},
++++++++//+Insert+some+documents
++++++++(callback)+=>+{
++++++++++++mongodb.collection('sandbox').insertMany(
++++++++++++++++[{a+:+1},+{a+:+2},+{a+:+3}],
++++++++++++++++(err)+=>+{
++++++++++++++++++++assert.equal(err,+null);
++++++++++++++++++++callback(null);
++++++++++++++++}
++++++++++++)
++++++++},
++++++++//+Find+some+documents
++++++++(callback)+=>+{
++++++++++++mongodb.collection('sandbox').find({}).toArray(function(err,+docs)+{
++++++++++++++++assert.equal(err,+null);
++++++++++++++++console.dir(docs);
++++++++++++++++callback(null);
++++++++++++});
++++++++}
++++],
++++()+=>+{
++++++++mongodb.close();
++++}
);|code-block|syntax|javascript|498294|entityMap|0|LINK|mutability|MUTABLE|url|http://caolan.github.io/async/docs.html^0|K|5|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Based on the suggestion from @mpobrien above, I've found the <a href="http://caolan.github.io/async/docs.html" rel="nofollow noreferrer">async</a> module to be incredibly helpful in this regard. Here's an example pattern that I've come to adopt:

<pre><code>const assert = require('assert');
const async = require('async');
const MongoClient = require('mongodb').MongoClient;

var mongodb;

async.series(
 [
 // Establish Covalent Analytics MongoDB connection
 (callback) =&gt; {
 MongoClient.connect('mongodb://localhost:27017/test', (err, db) =&gt; {
 assert.equal(err, null);
 mongodb = db;
 callback(null);
 });
 },
 // Insert some documents
 (callback) =&gt; {
 mongodb.collection('sandbox').insertMany(
 [{a : 1}, {a : 2}, {a : 3}],
 (err) =&gt; {
 assert.equal(err, null);
 callback(null);
 }
 )
 },
 // Find some documents
 (callback) =&gt; {
 mongodb.collection('sandbox').find({}).toArray(function(err, docs) {
 assert.equal(err, null);
 console.dir(docs);
 callback(null);
 });
 }
 ],
 () =&gt; {
 mongodb.close();
 }
);
</code></pre>

blocks|key|713831|text|这是我想出的一个解决方案。它避免使用toArray，而且非常简短：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|713832|var+MongoClient+=+require('mongodb').MongoClient;

MongoClient.connect("mongodb://localhost:27017/mydb",+function(err,+db)+{
++let+myCollection+=+db.collection('myCollection');
++let+query+=+{};+//+fill+in+your+query+here
++let+i+=+0;
++myCollection.count(query,+(err,+count)+=>+{+
++++myCollection.find(query).forEach((doc)+=>+{
++++++//+do+stuff+here
++++++if+(%2B%2Bi+==+count)+db.close();
++++});
++});
});|code-block|syntax|javascript|713833|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a solution I came up with. It avoids using toArray and it's pretty short and sweet:

<pre><code>var MongoClient = require('mongodb').MongoClient;

MongoClient.connect("mongodb://localhost:27017/mydb", function(err, db) {
 let myCollection = db.collection('myCollection');
 let query = {}; // fill in your query here
 let i = 0;
 myCollection.count(query, (err, count) =&gt; { 
 myCollection.find(query).forEach((doc) =&gt; {
 // do stuff here
 if (++i == count) db.close();
 });
 });
});
</code></pre>

blocks|key|713890|text|没有计数器、库或任何自定义代码的现代方式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|713891|let+MongoClient+=+require('mongodb').MongoClient;
let+url+=+'mongodb://yourMongoDBUrl';
let+database+=+'dbName';
let+collection+=+'collectionName';

MongoClient.connect(url,+{+useNewUrlParser:+true+},+(mongoError,+mongoClient)+=>+{
+++if+(mongoError)+throw+mongoError;

+++//+query+as+an+async+stream
+++let+stream+=+mongoClient.db(database).collection(collection)
++++++++.find({})+//+your+query+goes+here
++++++++.stream({
++++++++++transform:+(readElement)+=>+{
++++++++++++//+here+you+can+transform+each+element+before+processing+it
++++++++++++return+readElement;
++++++++++}
++++++++});

+++//+process+each+element+of+stream+(async)
+++stream.on('data',+(streamElement)+=>+{
++++++++//+here+you+process+the+data
++++++++console.log('single+element+processed',+streamElement);
+++});

+++//+called+only+when+stream+has+no+pending+elements+to+process
+++stream.once('end',+()+=>+{
+++++mongoClient.close().then(r+=>+console.log('db+successfully+closed'));
+++});
});|code-block|syntax|javascript|713892|在3.2.7版本的mongodb驱动程序上进行了测试，但根据链接可能是有效的，因为version+2.0|offset|length|713893|entityMap|0|LINK|mutability|MUTABLE|url|https://mongodb.github.io/node-mongodb-native/2.0/tutorials/streams/^0|0|0|15|B|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Modern way of doing this without counters, libraries or any custom code:

<pre><code>let MongoClient = require('mongodb').MongoClient;
let url = 'mongodb://yourMongoDBUrl';
let database = 'dbName';
let collection = 'collectionName';

MongoClient.connect(url, { useNewUrlParser: true }, (mongoError, mongoClient) =&gt; {
 if (mongoError) throw mongoError;

 // query as an async stream
 let stream = mongoClient.db(database).collection(collection)
 .find({}) // your query goes here
 .stream({
 transform: (readElement) =&gt; {
 // here you can transform each element before processing it
 return readElement;
 }
 });

 // process each element of stream (async)
 stream.on('data', (streamElement) =&gt; {
 // here you process the data
 console.log('single element processed', streamElement);
 });

 // called only when stream has no pending elements to process
 stream.once('end', () =&gt; {
 mongoClient.close().then(r =&gt; console.log('db successfully closed'));
 });
});
</code></pre>

Tested it on version 3.2.7 of mongodb driver but according to link might be valid since <a href="https://mongodb.github.io/node-mongodb-native/2.0/tutorials/streams/" rel="nofollow noreferrer">version 2.0</a>

blocks|key|498442|text|这里是the+answer+given+by+pkopac的扩展示例，因为我必须弄清楚其余的细节：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|498443|const+client+=+new+MongoClient(uri);
(async+()+=>+await+client.connect())();

//+use+client+to+work+with+db
const+find+=+async+(dbName,+collectionName)+=>+{
++try+{
++++const+collection+=+client.db(dbName).collection(collectionName);
++++const+result+=+await+collection.find().toArray()
++++return+result;
++}+catch+(err)+{
++++console.error(err);
++}
}

const+cleanup+=+(event)+=>+{+//+SIGINT+is+sent+for+example+when+you+Ctrl%2BC+a+running+process+from+the+command+line.
++client.close();+//+Close+MongodDB+Connection+when+Process+ends
++process.exit();+//+Exit+with+default+success-code+'0'.
}

process.on('SIGINT',+cleanup);
process.on('SIGTERM',+cleanup);|code-block|syntax|javascript|498444|这是一个link+to+the+difference+between+SIGINT和SIGTERM。我必须添加process.exit()，否则在命令行运行进程上执行Ctrl+%2B+C时，我的节点web服务器不会干净地退出。|style|CODE|498445|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/27667203/1534823|1|https://unix.stackexchange.com/questions/31637/ctrl-c-will-not-kill-process/231439#231439^0|3|Q|0|0|0|Z|6|16|7|1J|E|2B|8|4|U|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@$A|12|B|13|K|L]|$A|14|B|15|K|L]|$A|16|B|17|K|L]|$A|18|B|19|K|L]]|9|@$A|1A|B|1B|1|1C]]|C|$]]|$1|M|3|-4|5|6|7|1D|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

Here an extended example to <a href="https://stackoverflow.com/a/27667203/1534823">the answer given by pkopac</a>, since I had to figure out the rest of the details:
<pre><code>const client = new MongoClient(uri);
(async () =&gt; await client.connect())();

// use client to work with db
const find = async (dbName, collectionName) =&gt; {
 try {
 const collection = client.db(dbName).collection(collectionName);
 const result = await collection.find().toArray()
 return result;
 } catch (err) {
 console.error(err);
 }
}

const cleanup = (event) =&gt; { // SIGINT is sent for example when you Ctrl+C a running process from the command line.
 client.close(); // Close MongodDB Connection when Process ends
 process.exit(); // Exit with default success-code '0'.
}

process.on('SIGINT', cleanup);
process.on('SIGTERM', cleanup);
</code></pre>
Here is a <a href="https://unix.stackexchange.com/questions/31637/ctrl-c-will-not-kill-process/231439#231439">link to the difference between</a> <code>SIGINT</code> and <code>SIGTERM</code>.
I had to add the <code>process.exit()</code>, otherwise my node web-server didn't exit cleanly when doing <code>Ctrl + C</code> on the running process in command line.

Working with Nodejs and MongoDB through Node MongoDB native driver. Need to retrieve some documents, and make modification, then save them right back. This is an example:

<pre><code>db.open(function (err, db) {
 db.collection('foo', function (err, collection) {
 var cursor = collection.find({});
 cursor.each(function (err, doc) {
 if (doc != null) {
 doc.newkey = 'foo'; // Make some changes
 db.save(doc); // Update the document
 } else {
 db.close(); // Closing the connection
 }
 });
 });
});
</code></pre>

With asynchronous nature, if the process of updating the document takes longer, then when cursor reaches the end of documents, database connection is closed. Not all updates are saved to the database.

If the <code>db.close()</code> is omitted, all the documents are correctly updated, but the application hangs, never exits.

I saw a post suggesting using a counter to track number of updates, when fall back to zero, then close the db. But am I doing anything wrong here? What is the best way to handle this kind of situation? Does <code>db.close()</code> have to be used to free up resource? Or does a new db connection needs to open?

When to close MongoDB database connection in Nodejs

数据库

服务器

MongoDB

通过Node MongoDB本机驱动程序与Nodejs和MongoDB一起工作。需要检索一些文档，并进行修改，然后将它们保存回来。这是一个示例：db.open(function (err, db) {  db.collection('foo', function (err, collection) {    var c...

问何时关闭Nodejs中的MongoDB数据库连接
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问何时关闭Nodejs中的MongoDB数据库连接EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问何时关闭Nodejs中的MongoDB数据库连接
EN