Continuation Style Passing

• "No procedure is allowed to return to its caller--ever."
• "Procedures can take a callback to invoke upon their return value."

Continuation Style Passing

//without CSP
function self  (x) { return x; }
function addOne(x) { return 1 + x; }
function double(x) { return 2 * x; }

//without CSP
var startVal = 2;
var selfed   = self(startVal);
var oneAdded = addone(selfed);
var doubled  = double(oneAdded);

console.log(doubled);   // output: 6

Continuation Style Passing

//WITH CSP
function self  (x, cb) { cb(x); }
function addOne(x, cb) { cb(1 + x); }
function double(x, cb) { cb(2 * x); }

//WITH CSP
var startVal = 2;

self(startVal, function (selfed){
  //do stuff with selfed
});

double(starVal, function(doubled){
  //do stuff with doubled value
});

//WITH CSP
function self  (x, cb) { cb(x); }
function addOne(x, cb) { cb(1 + x); }
function double(x, cb) { cb(2 * x); }

var startVal = 2;

self(startVal, function (selfed){

  addOne(selfed, function (oneAdded){

    double(oneAdded, function (doubled){

      console.log(doubled); //outputs 6

    });

  });

});

Yikes!

Option 1

  try{
    var results = readFile('myFile');
  }catch(e){
    console.error('bad things :(');
  }
  console.log(results);

  //do other stuff later...

Blocking!

Option 2

  readFile('myFile', function(err, results){
    if(err){ return console.error('bad things :(');
    console.log(results);
  });

  //do other stuff right away!

fs.readfile

//filename: async-flow-control/start/read-file.js
var fs = require('fs');
var filename = 'letter.txt';

fs.readFile(filename, callback);

function callback(err, data){
  //if err, console.error(err)
  //else console.log file contents
}

Hints:

1. data is a Buffer. It has a .toString method
2. Path to letter.txt is relative to CWD

Node callback conventions

asyncOperation(/*...*/, function(error, /*...*/);

1. Callback always last argument
2. Callback takes error as first argument

Callback Review

• Continuation Style Passing
• Node conventions

Up Next: Callback Hell

fs.readFile('users.json', 'utf-8', function (err, contents){
  if(err){ throw err; }
  var users = JSON.parse(contents);
  users.forEach(function(user){
    db.accounts.findOne({id: user.id}, function(err, address){
      if(err){ throw err; }
      var filename = 'address' + address.id + '.json';
      fs.writeFile(filename, 'utf-8', address, function(err){
        if(err){ throw err; }
        console.log(filename + ' written successfully!');
      });
    });
  });
});

Name functions

fs.readFile('users.json', 'utf-8', function processUsers(err, contents){
  if(err){ throw err; }
  var users = JSON.parse(contents);
  users.forEach(function lookupAddress(user){
    db.accounts.findOne({id: user.id}, function writeAddress(err, address){
      if(err){ throw err; }
      var filename = 'address' + address.id + '.json';
      fs.writeFile(filename, 'utf-8', address, function outputResults(err){
        if(err){ throw err; }
        console.log(filename + ' written successfully!');
      });
    });
  });
});

Externalize functions

fs.readFile('users.json', 'utf-8', processUsers);

function processUsers(err, contents){
  if(err){ throw err; }
  var users = JSON.parse(contents);
  users.forEach(lookupAddress);
});

function lookupAddress(user){
  db.accounts.findOne({id: user.id}, writeAddress);
}

function writeAddress(err, address){
  if(err){ throw err; }
  var filename = 'address' + address.id + '.json';
  fs.writeFile(filename, 'utf-8', address, outputResults);
}

function outputResults(err){
  if(err){ throw err; }
  console.log(filename + ' written successfully!');
}

Clean up the following callback heck:

//async-flow-control/start/callback-heck.js

function self  (x, cb) { cb(null, x); }
function addOne(x, cb) { cb(null, 1 + x); }
function double(x, cb) { cb(null, 2 * x); }

var startVal = 2;

self(startVal, function (err, selfed){
  addOne(selfed, function (err, oneAdded){
    double(oneAdded, function (err, doubled){
      console.log(doubled); //outputs 6
    });
  });
});

Hints:

1. name functions
2. externalize functions

Up Next: EventEmitters

EventEmitter

• Interface
• Main methods:
  • on(event, handlerFunction)
  • emit(event, data)

EventEmitter vs. Callback style

• EventEmitter can trigger various events
• An event can have multiple listeners
• Event handler:
  • may be run many times
  • has no "error first" convention

Example

//async-flow-control/event-emitter-example.js
var EventEmitter = require('events');
var ee = new EventEmitter();

ee.on('message', function logMessage(msg){
  console.log('new message: ' + msg.text);
});

ee.emit({ text : 'hello!', sender: 'sequoia'});
ee.emit({ text : 'world!', sender: 'sequoia'});

var messages = [];

ee.on('message', function collectMessage(msg){
  messages.push(msg);
});

start/event-emitter.js

1. Emit increment each time counter is incremented
2. Send the counter value as event data
3. Attach listener that logs the new counter value

Hints:

1. emitter.emit(name, data)
2. emitter.on(name, function(data){})

Extra Credit:

1. If counter is 3, emit done event
2. Attach handler to done to log "DONE" then process.exit()

Up Next: Promises

Promises

What is a promise?

• Object
• Has a "then" method
• Resolves only once
• Has a state:
  • pending
  • fulfilled
  • rejected

.then method

1. onFulfilled function
2. onRejected function

readFilePromise('users.json')
  .then(
    function success(results){
      console.log(results);
    },
    function failure(err){
      console.error(err);
    }
  );

Chaining

var promise = readFilePromise('users.json');

promise
  .then(filterUsers, handleError)
  .then(formatRecords, handleError)
  .then(writeFile, handleError);

Promises are Objects

function getUser(id){
  return restPromiseAPI.getOne({
    type : 'user',
    id   : id
  });
}

var userPromise = getUser(id);

userPromise.then(updateUI, logError);

Wrapping a Callback Function

function readFilePromise(filename){

  return new Promise(function(resolve, reject){

    fs.readFile(filename, 'utf-8', function(err, contents){

      if(err) return reject(err);

      resolve(contents);

  });

}

"Promisify" readFile. This should work:

//filename: async/read-file-promise.js

function print(text){ /*...*/ }
function handleError(err){ /*...*/ }

readFile('letter.txt')
  .then(print, handleError);

Hints:

1. Remember file encoding
2. Return a Promise

function returnsPromise(){
  return new Promise(function(resolve, reject){
    // do something...
    // reject(err); //or
    // resolve(results);
  });
}

Bluebird: promises and more

http://bluebirdjs.com/

• catch method
• Additional methods (map, filter, etc.)
• Utility functions: promisify & promisifyAll

Using Bluebird to "promisify" an API

Promise = require('bluebird');
var fs = Promise.promisifyAll(require(fs));

fs.readFileAsync('myfile.txt', 'utf-8')
  .then(print)
  .catch(handleError);

Utilities

Promise = require('bluebird');
var fs = Promise.promisifyAll(require(fs));

fs.readFileAsync('users.json', 'utf-8')
  .then(JSON.parse)
  .filter(justAdmins)
  .tap(function log(admins){
    console.log(admins);
  })
  .map(sendNotification)
  .then(doTheNextThing)
  .catch(handleError);

function justAdmins(user){
  return user.role == 'admin';
}

Up Next: The Event Loop