能否认定未返回Promise/Observable的JS函数为同步函数？若不能该如何判断？

Great question! To cut straight to the point: No, you can’t safely assume a function is synchronous just because it doesn’t return a Promise or Observable. There are plenty of asynchronous functions that don’t use these return types—let’s break this down, then cover how to actually tell if a function is sync or async.

Why the initial assumption fails #

Asynchronous behavior in JavaScript doesn’t only come from Promises or Observables. Functions can be asynchronous by relying on browser/Node.js APIs that use callbacks or schedule work for later in the event loop, without returning a Promise/Observable at all.

For example, this function is clearly asynchronous, but it returns nothing:

function asyncWithoutPromise() {
  // Schedules work to run after the current call stack empties
  setTimeout(() => {
    console.log("This runs asynchronously!");
  }, 0);
}

asyncWithoutPromise();
console.log("This runs first!");
// Output order: "This runs first!" → "This runs asynchronously!"

Another example: a DOM event listener setup function—it doesn’t return a Promise, but the callback it defines runs asynchronously when the event fires:

function setupButtonClick() {
  document.querySelector("button").addEventListener("click", () => {
    console.log("Click happened later!");
  });
}

How to determine if a function is synchronous or asynchronous #

Here are practical ways to check:

• Inspect the function’s code for asynchronous APIs: Look for calls to APIs that schedule deferred work, like:

  • Timer functions: setTimeout, setInterval, requestAnimationFrame
  • I/O operations (Node.js): fs.readFile, http.get (callback-based versions)
  • DOM APIs: addEventListener (callback-driven event handling)
  • Any function that queues work to run in a later event loop phase.

• Test execution order: Run the function followed by a synchronous log, and see which runs first. If the function’s logic runs after the log, it’s asynchronous (like the setTimeout example above). For functions that take callbacks, check if the callback runs before or after the function returns:

  function testCallbackFunc(cb) {
    setTimeout(cb, 0);
  }
  
  let callbackRan = false;
  testCallbackFunc(() => { callbackRan = true; });
  console.log(callbackRan); // Logs false—callback runs asynchronously
  

• Check documentation or type definitions: If you’re using a third-party function, check its docs for mentions of asynchronous behavior. For TypeScript users, type definitions might indicate async behavior (though callback-based functions may not always have explicit markers).

• Wrap it in a Promise (for callback-based functions): If the function uses callbacks, you can promisify it to make its asynchronous behavior explicit. In Node.js, you can use util.promisify, or write a simple wrapper:

  const util = require('util');
  const asyncCallbackFunc = (cb) => setTimeout(cb, 100);
  const promisifiedFunc = util.promisify(asyncCallbackFunc);
  
  // Now you can use await to confirm it's async
  async function test() {
    console.log("Before");
    await promisifiedFunc();
    console.log("After"); // Runs after the timeout
  }
  test();
  

内容的提问来源于stack exchange，提问作者Tibin Thomas