JavaScript 库中的阻塞/非阻塞函数？

Question

I'm porting a library that includes cpu-expensive functions that need to be able to be used in either synchronous or async mode. What is the best way to implement these functions in current JavaScript (setTimeout, web-workers, something else) given that they need to work in both node and the browser?

Answer 1

I would have two versions of each function, and have the async version return a promise rather than accept a callback argument.

How you do that is up to you. You could literally return a promise then resolve/reject it, or you could mark the functions as async which makes them implicitly return a promise, then return the response (which is like resolving with a value).

class LibClass {
  a() { // async a with promises returns Promise<ret>
    return new Promise((resolve, reject) => {
      setTimeout(() => {
        const ret = doWork()
        resolve(ret)
      }, 1)
    })
  }
  a_sync() { // sync a returns ret
    const ret = doWork()
    return ret
  }
  async b(data) { // async function b returns Promise<ret>
    const ret = doWork()
    return ret
  }
}

Answer 2

This sounds like you're a bit confused about synchronous and asynchronous. A given function either has a synchronous result or an asynchronous result. One or the other. That fact is determined by what the function does, not by what a caller thinks or wants.

If a function calls anything asynchronous or might call anything asynchronous inside its implementation, then its final result IS asynchronous and there's no way to make it synchronous. It MUST have an asynchronous interface. You can't offer a synchronous interface as the result is simply not available to return synchronously.

If a function does not call anything asynchronous inside its implementation, then it's a synchronous function and you should give it a synchronous interface because that's always easier to use than an asynchronous interface and a synchronous interface can also be used with other asynchronous code so it's plenty flexible.

So, if you had an entirely synchronous library, you could offer both a synchronous and an asynchronous interface, but there is no reason to do so. Just offer a synchronous interface as it's always easier to use.

And, ANY function in the library that does anything asynchronous MUST have an asynchronous interface.

So, the choice is determined by what you're doing in your library functions and nothing else.

---

FYI, very occasionally, there might be a function that sometimes has a synchronous result and sometimes has an asynchronous result. The canonical example of this is when a value might already be cached locally and available immediately, but if not in the cache, it has to be retrieved asynchronously from some remote resource. In this case, you provide an asynchronous interface and, even when the result is immediately available, you still return it asynchronously. This is so the caller gets one unified interface that works either way and the caller doesn't have to code two separate ways to use your function. Note: this should be a rare case in a library design, not the usual case. Usually, a function is either internally synchronous or asynchronous all the time.

Answer 3

you can use async keyword like :

class LibClass{
      async a(){
         return Promise.resolve('success');
        }
}