current community

your communities

more stack exchange communities

Stack Exchange
tour help
Take the 2-minute tour ×
Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. It's 100% free, no registration required.
up vote 8 down vote favorite
1

I've just started using node, and one thing I've quickly noticed is how quickly callbacks can build up to a silly level of indentation:

doStuff(arg1, arg2, function(err, result) {
    doMoreStuff(arg3, arg4, function(err, result) {
        doEvenMoreStuff(arg5, arg6, function(err, result) {
            omgHowDidIGetHere();
        });
    });
});

The official style guide says to put each callback in a separate function, but that seems overly restrictive on the use of closures, and making a single object declared in the top level available several layers down, as the object has to be passed through all the intermediate callbacks.

Is it ok to use function scope to help here? Put all the callback functions that need access to a global-ish object inside a function that declares that object, so it goes into a closure?

function topLevelFunction(globalishObject, callback) {

    function doMoreStuffImpl(err, result) {
        doMoreStuff(arg5, arg6, function(err, result) {
            callback(null, globalishObject);
        });
    }

    doStuff(arg1, arg2, doMoreStuffImpl);
}

and so on for several more layers...

Or are there frameworks etc to help reduce the levels of indentation without declaring a named function for every single callback? How do you deal with the callback pyramid?

share|improve this question
1  
Note additional issue with the closures - in JS closure captures the whole parent context (in other languages it only captures variable used or the ones the user specifically requested) causing some nice memory leaks if the callback hierarchy is deep enough and if, for instance, callback is retained somewhere. –  Eugene Oct 24 '13 at 18:19

2 Answers 2

up vote 3 down vote

Promises provide a clean separation of concerns between asynchronous behavior and the interface so asynchronous functions can be called without callbacks, and callback interaction can be done on the generic promise interface.

There is multiple implementations of "promises":

For example you can rewrite this nested callbacks

http.get(url.parse("http://test.com/"), function(res) {
    console.log(res.statusCode);
    http.get(url.parse(res.headers["location"]), function(res) {
        console.log(res.statusCode);
    });
});

like

httpGet(url.parse("http://test.com/")).then(function (res) {
    console.log(res.statusCode);
    return httpGet(url.parse(res.headers["location"]));
}).then(function (res) {
    console.log(res.statusCode);
});

Instead of callback in callback a(b(c())) you chain the ".then" a().then(b()).then(c()).

An introduction here: http://howtonode.org/promises

share|improve this answer
    
would you mind explaining more on what these resources do and why do you recommend these as answering the question asked? "Link-only answers" are not quite welcome at Stack Exchange –  gnat Oct 24 '13 at 13:07
1  
Ok, sorry. I have added an example and more informations. –  Fab Sa Oct 24 '13 at 13:32
up vote 2 down vote

As an alternative to promises you should have a look at the yield keyword in combination with generator functions which will be introduced in EcmaScript 6. Both are available today in Node.js 0.11.x builds, but require that you additionally specify the --harmony flag when running Node.js:

$ node --harmony app.js

Using those constructs and a library such as TJ Holowaychuk's co allow you to write asynchronous code in a style that looks like synchronous code, although it still runs in an asynchronous way. Basically, these things together implement co-routine support for Node.js.

Basically, what you need to do is to write a generator function for the code that runs asynchronous stuff, call the async stuff in there, but prefix it with the yield keyword. So, in the end your code looks like:

var run = function * () {
  var data = yield doSomethingAsync();
  console.log(data);
};

To run this generator function you need a library such as the before-mentioned co. The call then looks like:

co(run);

Or, to put it inline:

co(function * () {
  // ...
});

Please note that from generator functions you can call other generator functions, all you need to do is prefix them with yield again.

For an introduction to this topic, search Google for terms such as yield generators es6 async nodejs and you should find tons of information. It takes a while to get used to it, but once you get it, you don't want to go back ever.

Please note that this does not only provide you with a nicer syntax to call functions, it also allows you to use the usual (synchronous) control flow logic stuff, such as for loops or try / catch. No more messing around with lots of callbacks and all these things.

Good luck and have fun :-)!

share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.