同步vs异步Node.js

Question

I was automating a webpage using the Mocha testing framework, and came upon the terms Synchronous and Asynchronous code. I'm familiar with synchronous and asynchronous events when you send an HTTP request...but I've never heard of code being synchronous and asynchronous. Anyone care to explain...I saw on previous questions that it has something to do with a callback, but even then I'm still pretty confused about the concept.

Answer 1

Below is a simplified version of my server code. I demonstrate both synchronous code (after you start doing an operation, no further operations are begun until it finishes) and asynchronous code (you start doing an operation, then continue to do other operations, and at some later point you "callback" or get a result from the first operation.)

This has some important consequences. Nearly every time you call an async function:

• the return value from your async function is useless, because the function will return immediately, although finding the result takes a long time.

• you have to wait until the callback function is executed to have access to the result.

• lines of code following the call to the asynchronous function will execute BEFORE the asynchronous callback function runs.

As an example, the order of the console.logs in my code below will be:

line 3 - before sync
line 8 - after sync, before async
line 16 - after async call, outside callback
line 14 - inside async call and callback



// synchronous operations execute immediately, subsequent code
// doesn't execute until the synchronous operation completes.
console.log('line 3 - before sync');
var app = require('express')();
var cfgFile = require('fs').readFileSync('./config.json');
var cfg = JSON.parse(cfgFile);
var server = require('http').createServer(app);
console.log('line 8 - after sync, before async');

// When you call an asynchronous function, something starts happening,
// and the callback function will be run later:
server.listen(cfg.port, function(){
  // Do things that need the http server to be started
  console.log('line 14 - inside async call and callback');
});
console.log('line 16 - after async call, outside callback');

Answer 2

Synchronous code will strictly be processed line by line whereas asynchronous code will continue to the next line while previous lines of code are still being processed.

For asynchronous code, in the following snippet, you would expect World to be logged to console before Hello because the database query requires more of the computer's resources and therefore takes more time. console.log('World') would finish executing before the query.

var Person = mongoose.model('Person', personSchema);

Person.findOne({ 'name.last': 'Ghost' }, function(err, person) {
  if(err) 
    throw err;
  else
    console.log('Hello');
});

console.log('World');

In synchronous code, Hello will be logged before World because the query finishes executing before any following lines are executed.

Answer 3

Synchronous Code basically means the lines of code are executed in the order they are written. Synchronous events will immediately execute an associated callback like it would a direct function call so the end result is the same.

In general, Asynchronous Code is executed separately and concurrently from the calling code. eg Calling setTimeout will immediately return and execute the next expression but it will have started an action that at some point in the future it will fire an Asynchronous Event that calls the specified callback.

The Mocha test framework supports both types of code and it supplies the done() callback for asynchronous code. done() is the callback that lets Mocha know when the test complete.

Asynchronous test code, From http://mochajs.org/

describe('User', function() {
  describe('#save()', function() {
    it('should save without error', function(done) { // done is a callback
      var user = new User('Luna');
      user.save(function(err) { // save is async db call that starts here, completes whenever
        if (err) throw err;
        done();
      });
    });
  });
});

Testing synchronous code doesn't require done(), the test code is expected to executed in order. So when the last expression is executed, the test is over.