Proper way to skip a then function in Q Promises

It depends a bit on what the conditions to skip are, what kind of operations you are doing, and how “useful” the whole thing is when the conditions failed. You might be able to use a smart rejection here to bring the message across. Otherwise, I believe the correct way to deal with this is really a nested set of promise calls.

This also matches the core idea behind promises, which is to bring back synchronous control structures to asynchronous code execution. In general, when using promises, you should first think about how you would do the task with synchronous code. And if you think about your situation, it would probably work like this:

var contents = readFromFile();var results = initialOperation(contents);if (fancyCondition(results)) {     results = doSomething(results);     results = doMore(results);}processAndPrint(results);

So you would have a real branch in there in synchronous code. As such, it makes no sense that you would want to avoid that in asynchronous code using promises. If you could just skip things, you were essentially using jumps with gotos. But instead, you branch off and do some other things separately.

So going back to promises and asynchronous code, having an actual branch with another set of chained operations is completely fine, and actual in spirit of the intent behind promises. So above code could look like this:

readFromFile(fileName).then(initialOperation).then(function (results) {    if (fancyCondition(results) {        return doSomething(results)            .then(doMore);    }    return results;}).catch(errorHandler).then(processResults).then(outputResults); // Or `done` in Q

Also note, that the promise pipeline automatically looks a lot more cleaner when you start using functions that return promises on their own, instead of creating them inline from then.

But then we are nesting the thenable functions. This is what we wanted to avoid in the first place using promises.

No, this is indeed the proper way. For branching, you will always need an additional level of nesting. If indentation is getting too large, you still can apply the old trick of calling sub-procedures (which is also used for unnesting callback functions).

Other solutions are quite ugly. Skipping a few then-handlers in a chain, without deeper nesting, can be done by throwing an exception and rejecting the promise; this could be caught in the end then. It might apply to a few scenarios, but I wouldn't consider this a good idea.

The other way I could think of would be wrapping the conditional result in another data structure, which could be passed through the chain of thens. This would be like Maybe in Haskell or Option in Scala, and you would map over them in the handlers. However, this would also require an additional level of nesting, would be less efficient to explicitly propagate nothing through the chain, and would have problems with returned promises in the chain.

If I understand "skip" correctly, then the generic solution is not to return a value under "skip" conditions, thus allowing the input value to pass through transparently.

eg:

...then(function (randomInteger) {    var remainder = randomInteger % 2;    console.log(['Even','Odd'][remainder] + ' number: ', randomInteger);    if(remainder) {        return randomInteger + 1;    }})...