Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
use plain old functions asynchronously as node-style callbacks
JavaScript
branch: master

Fetching latest commit…

Cannot retrieve the latest commit at this time

Failed to load latest commit information.
README.md
node-asyncify.js
package.json

README.md

node-asyncify

use plain old functions asynchronously as node-style callbacks

Installation

$ npm install node-asyncify

Usage example

var asyncify = require('node-asyncify');
var async = require('async');
var fs = require('fs');

function foo() {
    console.log('unmitigated ungulate usurpers');
}

async.parallel([
        asyncify.partial(fs.readdir, __dirname),
        asyncify(foo)
    ],
    function () {
        console.log('indefatigable idolatry');
});

This will output:

    unmitigated ungulate usurpers
    indefatigable idolatry

and thrash your harddrisk in between.

API

    asyncify(syncFunction)

Takes a synchronous function syncFunction and returns it wrapped as a node-style async function which takes an (err, val) => any callback as its last parameter. The function is invoked with the original arguments. If syncFunction throws an error, it is used for the first argument err of the callback. Otherwise, err is null and the return value is the second parameter of the callback.

    asyncify.constant(val)
    // alias
    asyncify.K(val)

Takes a constant value val and returns it wrapped as a node-style async function which takes an (err, val) => any callback as its last parameter. The callback is invoked with err null and val as the second parameter.

    asyncify.error(err)

Takes a constant error err and returns it wrapped as a node-style async function which takes an (err, val) => any callback as its last parameter.

If err is an instanceof Error, it is used. Otherwise, a new Error is created with err as the parameter. For example, asyncify.error('invalid foo') is equivalent to asyncify.error(new Error('invalid foo')).

The callback is invoked with err as its first parameter.

asyncify.errorFirstify(fn)

Takes a call-back last style function that does not pass the error as the first callback parameter and wraps it so that it provides a (null) error first, followed by all of the original arguments. Callbacks should be (somewhat) consistent: cb(err, val) - for great justice. This does that.

asyncify.partial(fn, arg1, arg2, ..., argn)

Takes an async function, partially applies some arguments, and returns a function which takes only a callback.

asyncify.call(fn, thisArg, arg1, arg2, ..., argn)

Takes an async function, partially applies some arguments, and returns a function which takes only a callback. The original fn is invoked in the context of thisArg, with semantics equivalent to Function.call.

License

MIT. (c) 2012 jden - Jason Denizac jason@denizac.org

Something went wrong with that request. Please try again.