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 don't know how much exactly it would effect or the effect just can be ignored).

So I just create a little tool for flow control:

line.js

/**
 * Create the "next" function
 * 
 * @param {Array} tasks 
 * @param {Number} index
 * @param {Number} last
 */
var next = function(tasks, index, last) {

    if (index == last) {

        return tasks[index + 1];
    }
    else {

        return function(data) {

            var nextIndex = index + 1;
            tasks[nextIndex](next(tasks, nextIndex, last), data);
        };
    }
};

/**
 * Invoke functions in line.
 */
module.exports = function() {

    var tasks = arguments,
        last = tasks.length - 2;

    tasks[0](next(tasks, 0, last));
};

usage:

var line = require("line.js");
line(function(next) {

    someObj.find(function(err, docs) {

        // codes
        next(docs);
    });
}, function(next, docs) {

    // codes
});

Hope this helps.

EDIT END

As all know,
Node's built-in or third-part modules often provides async API,
and using "callback" function for dealing the results.

It's cool but sometimes would code like this:

                   //some codes
              }
         }
    }
}

codes like this are hard to read.

I know "deferred" library can solve such problem,
Is there any good "deferred" module for Node?
And How is the performance if I code Node with "deferred"?

回答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.

回答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 :)

回答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.

回答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

回答5:

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

来源：https://stackoverflow.com/questions/10278721/about-nodes-code-style

标签

javascript

node.js

coding-style

deferred