Use async code in class constructor I have some situations where I run async code inside class constructor:
1. Run async code that returns a response
I execute some async code that returns a response, then I apply then and catch inside class constructor:
class MyClass {

  constructor(
    someParameter,
    anotherParameter,
  ) {
    // Run async code that return a response
    someAsyncCode()
      .then( // do something with result of someAsyncCode )
      .catch( // do something if someAsyncCode goes wrong )  
  }
}

2. Run async code that doesn't return a response
In some situations, the async code doesn't return anything, but I need to run it.
class MyClass {

  constructor(
    someParameter,
    anotherParameter,
  ) {
    // Run async code that doesn't return anything
    someAsyncCode()
  }

  async someAsyncCode() {
    const someAsyncResult = await something();
    // execute some other logic but not return anything
  }
}

Questions

Its a good or bad practice, execute some async code inside class constructor?
in the situation where you need to execute async code that does not return anything, it is necessary to execute then and catch?
what are the implications of executing asyn code without then and catch?
Its a good or bad practice, execute some async code inside class constructor?

Constructors are always synchronous and should succeed to create an object immediately. If your async call doesn't block that and you don't care about the success of your async call, then it is not a bad practice to call the function without awaiting it, and immediately .catch and handle any possible rejections.
In general, if you don't need the return value of an async call and you don't want to wait for it to complete, you should not await it. But, you should still handle rejections with a .catch; even if you do nothing: something().catch(() =&gt; {})

in the situation where you need to execute async code that does not return anything, it is necessary to execute then and catch? what are the implications of executing async code without then and catch?

Having a then is unnecessary, and would only be useful if you wanted to do something when the Promise has resolved, but if the Promise can be rejected you must have a catch.
If you do not catch a rejected promise you will have an unhandledPromiseRejection which, if left unhandled, will crash your process in a future version of Node.js.
If you did care about the return value, or you want the caller to be able to handle rejections, you can make the constructor private and then add a static async factory function that uses the private constructor:
class MyClass {

  private constructor(
    someParameter,
    anotherParameter,
  ) {
    // No async calls here
  }

  static async create (
    someParameter,
    anotherParameter,
  ) {
    await something();
    return new MyClass(someParameter, anotherParameter);
  }

}

Then you would use MyClass.create(x,y) to instantiate it, instead of new MyClass(x,y).