Home » Nodejs » Determine whether a method is synchronous or asynchronous

Determine whether a method is synchronous or asynchronous

Posted by: admin November 29, 2017 Leave a comment


In node.js, is it possible to determine (using a function) whether a method is synchronous or asynchronous?

I’d like to write a function that does the following:

function isSynchonous(methodName) {
    //if the method is synchronous, return true. Otherwise, return false.

From a language standpoint this is not possible, which I believe llambda’s answer proves.

  • Functions can do things asynchronously but return something synchronously; say, return the number of async tasks that were fired off.
  • Functions can synchronously return promises… that represent asynchronous information. I would call such a method asynchronous but the language can’t really tell that.
  • In some perverse sense every asynchronous function “returns” something… undefined if nothing else.

From an engineering standpoint:

  • read the documentation.
  • If the function accepts a callback, it is likely asynchronous. Look at the function signature.
  • Read the code.
  • Use “common sense.” If the function does IO and returns a result from IO it must be, in some case, asynchronous. This includes file reading, reading from standard input, saving to a database, and HTTP/AJAX requests. Note streams are often used for this, which represents an asynchronous task, but the callbacks are special.

Furthermore there are functions that mix the two.

function(callback) {
    if(ready) {
    else {
        setTimeout(callback, 5000);

Arguably this is very evil, and correct practice would be

if(ready) {

so the function has uniform behavior.

However there is a hacky way to tell if anything asynchronous happened, at least in Node.js. See this discussion.

// untested!! please read the documentation on these functions before using yourself
var work = process._getActiveHandles().length + process._getActiveCallbacks().length;
var newWork = (process._getActiveHandles().length + process._getActiveCallbacks().length) - work;
if(newWork > 0) {
    console.log("asynchronous work took place.");

This works because asynchronous work cannot resolve on the same tick, by definition, and because Node.js is single threaded.


You don’t necessarily know. A function could even be randomly synchronous or asynchronous.

For example, a function that takes another function could execute that function immediately, or it could schedule to execute it at a later time using setImmediate or nextTick. The function could even randomly choose to call its passed function synchronously or asynchronous, such as:


function maybeSynchOrAsync(fun) {

  var rand = Math.floor((Math.random() * 2))

  if (rand == 0) {
    console.log('Executing passed function synchronously')
  } else {
    console.log('Executing passed function asynchronously via setImmediate')

maybeSynchOrAsync(function () { console.log('The passed function has executed.') });

Further, technically speaking, every function call is synchronous. If you call a function F, and F queues a callback function to be invoked later (using setTimeout or whatever mechanism), the original function F still has a synchronous return value (whether it’s undefined, a promise, a thunk, or whatever).


No, that’s impossible. The methods aren’t just marked synchronous or asynchronous, they either use callbacks or they don’t.