About Node's Code Style

EDIT thx to all the answers, and finally I decide to use some tools like Step, all I need is 'flow control' and don't want any thing else which may slow down the performance (I d

Solution 1:

It is a large problem with Node-based code; you frequently grow "callback pyramids". There are several approaches to dealing with the problem:

Code style:

Use this annoyance as an opportunity to break your code into bite sized chunks. It means you're likely going to have a proliferation of tiny named funcs - that's probably just fine, though! You might also find more opportunities for reuse.

Flow-control Libraries

There are exactly 593.72 billion flow control libraries out there. Here's some of the more popular ones:

• Step super basic serial & parallel flow management.
• seq is a heavier but more feature-full flow control library.
• There's plenty more. Search the npm registry for "flow" and "flow control" (sorry, doesn't appear to be linkable)

Language Extensions

There are several attempts to provide a more synchronous-feeling syntax on top of JavaScript (or CoffeeScript), often based on the concepts behind the tame paper.

• TameJS is the OkCupid team's answer to this.
• IcedCoffeeScript they've also ported TameJS over CoffeeScript as a fork.
• streamline.js is very similar to TameJS.
• StratifiedJS is a heavier approach to the problem.

This route is a deal-breaker for some:

• It's not standard JavaScript; if you are building libraries/frameworks/etc, finding help will be more difficult.
• Variable scope can behave in unexpected ways, depending on the library.
• The generated code can be difficult to debug & match to the original source.

The Future:

The node core team is very aware of the problem, and are also working on lower level components to help ease the pain. It looks like they'll be introducing a basic version of domains in v0.8, which provide a way of rolling up error handling (avoiding the common return err if err pattern, primarily).

This should start to lay a great foundation for cleaner flow control libraries, and start to pave the way for a more consistent way of dealing with callback pyramids. There's too much choice out there right now, and the community isn't close to agreeing on even a handful of standards yet.

References:

• Mixu's Node book has an awesome chapter on this subject.

Solution 2:

There are tons of "deferred libraries". Have a look there http://eirikb.github.com/nipster/#promise and there http://eirikb.github.com/nipster/#deferred. To pick one, it's only a matter of style & simplicity :)

Solution 3:

If you really don't like that, there's always the alternative of using named functions, which will reduce the indentation.

Instead of

setTimeout(function() {
  fs.readFile('file', function (err, data) {
    if (err) throw err;
    console.log(data);
  })
}, 200);

You can do this:

function dataHandler(err, data)
{
  if (err) throw err;
  console.log(data);
}

function getFile()
{
  fs.readFile('file', dataHandler);
}

setTimeout(getFile, 200);

The same thing, no nesting.

Solution 4:

There are some libraries that may be useful in some scenarios, but as a whole you won't be excited after using them for everything.

According to the slowness issues. Since node.js is async, the wrapped functions are not such a big performance consumer.

You could look here for deferred-like library

https://github.com/kriszyp/node-promise

Also this question is very similar

What nodejs library is most like jQuery's deferreds?

And as a final bonus I suggest you take a look at CoffeeScript. It is a language, which compiles to javascript and has more beautiful syntax, since the function braces are removed

Solution 5:

I usually like to use the async.js library as it offers a few different options on how to execute the code