Function

denodeify (nodeFunc, options) Function public

Module: rsvp

Defined in node_modules/rsvp/lib/rsvp/node.js:44

nodeFunc
Function
a 'node-style' function that takes a callback as its last argument. The callback expects an error to be passed as its first argument (if an error occurred, otherwise null), and the value from the operation as its second argument ('function(err, value){ }').
options
Boolean|Array
An optional paramter that if set to `true` causes the promise to fulfill with the callback's success arguments as an array. This is useful if the node function has multiple success paramters. If you set this paramter to an array with names, the promise will fulfill with a hash with these names as keys and the success parameters as values.
returns
Function
a function that wraps `nodeFunc` to return a `Promise`

denodeify takes a 'node-style' function and returns a function that will return an Promise. You can use denodeify in Node.js or the browser when you'd prefer to use promises over using callbacks. For example, denodeify transforms the following:

1
2
3
4
5
6

let fs = require('fs');

fs.readFile('myfile.txt', function(err, data){
  if (err) return handleError(err);
  handleData(data);
});

into:

1
2
3
4

let fs = require('fs');
let readFile = denodeify(fs.readFile);

readFile('myfile.txt').then(handleData, handleError);

If the node function has multiple success parameters, then denodeify just returns the first one:

1
2
3
4
5

let request = denodeify(require('request'));

request('http://example.com').then(function(res) {
  // ...
});

However, if you need all success parameters, setting denodeify's second parameter to true causes it to return all success parameters as an array:

1
2
3
4
5
6

let request = denodeify(require('request'), true);

request('http://example.com').then(function(result) {
  // result[0] -> res
  // result[1] -> body
});

Or if you pass it an array with names it returns the parameters as a hash:

1
2
3
4
5
6

let request = denodeify(require('request'), ['res', 'body']);

request('http://example.com').then(function(result) {
  // result.res
  // result.body
});

Sometimes you need to retain the this:

1
2

let app = require('express')();
let render = denodeify(app.render.bind(app));

The denodified function inherits from the original function. It works in all environments, except IE 10 and below. Consequently all properties of the original function are available to you. However, any properties you change on the denodeified function won't be changed on the original function. Example:

1
2
3
4
5
6

let request = denodeify(require('request')),
    cookieJar = request.jar(); // <- Inheritance is used here

request('http://example.com', {jar: cookieJar}).then(function(res) {
  // cookieJar.cookies holds now the cookies returned by example.com
});

Using denodeify makes it easier to compose asynchronous operations instead of using callbacks. For example, instead of:

1
2
3
4
5
6
7
8
9

let fs = require('fs');

fs.readFile('myfile.txt', function(err, data){
  if (err) { ... } // Handle error
  fs.writeFile('myfile2.txt', data, function(err){
    if (err) { ... } // Handle error
    console.log('done')
  });
});

you can chain the operations together using then from the returned promise:

1
2
3
4
5
6
7
8
9
10
11

let fs = require('fs');
let readFile = denodeify(fs.readFile);
let writeFile = denodeify(fs.writeFile);

readFile('myfile.txt').then(function(data){
  return writeFile('myfile2.txt', data);
}).then(function(){
  console.log('done')
}).catch(function(error){
  // Handle error
});