The Promise constructor initializes an object that tracks the lifecycle of an asynchronous operation, transitioning from a pending state to either fulfilled or rejected. It accepts an executor function containing two control parameters: a resolution function to mark success and a rejection function to signal failure.

Because the executor executes synchronously at the moment of instantiation, direct usage triggers the underlying logic immediately. To defer execution until explicitly called, encapsulate the constructor within a factory function:

function initiateAsyncProcess(delayMs) {
  return new Promise((onSuccess, onError) => {
    setTimeout(() => {
      console.log('Background task completed.');
      onSuccess({ metadata: 'Task finalized', id: Date.now() });
    }, delayMs);
  });
}

The factory returns a promise instance, exposing .then() to register continuation handlers. When onSuccess is invoked, any passed arguments propagate directly to the next .then() block. This mechanism decouples asynchronous logic from callback nesting:

initiateAsyncProcess(1000)
  .then((result) => {
    console.log(result.metadata);
    return initiateAsyncProcess(1500);
  })
  .then((subsequentResult) => {
    console.log(subsequentResult.metadata);
    return 'Static fallback value';
  })
  .then((staticData) => {
    console.log(staticData);
  });

Chaining works by each .then() returning a new promise that resolves with the return value of its handler. Returning another promise pauses the chain until that inner operation settles, enabling strict sequential execution.

Failure states require explicit interception. The .then() method accepts an optional second callback for rejection handling, but utilizing .catch() provides cleaner syntax and identical functionality:

function evaluateRandomMetric() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const value = Math.random() * 10;
      value >= 5 ? resolve({ thresholdMet: true, value }) : reject({ thresholdMet: false, reason: 'Value too low' });
    }, 800);
  });
}

evaluateRandomMetric()
  .then((data) => console.log('Resolved:', data))
  .catch((error) => console.log('Rejected:', error.reason));

Additionally, .catch() captures synchronous exceptions thrown inside preceding .then() handlers, preventing uncaught runtime crashes and centralizing error management similar to a traditional try/catch block.

For concurrent operations, Promise.all() accepts an iterable of promises and returns a single promise that resolves when every input promise fulfills. The resolution value is an array matching the order of the inputs, regardless of completion timing:

Promise.all([
  initiateAsyncProcess(1000),
  initiateAsyncProcess(2000),
  initiateAsyncProcess(1500)
]).then((collection) => {
  console.log('All resolved:', collection);
});

Conversely, Promise.race() settles as soon as the first promise in the iterable finishes, adopting its outcome. This pattern is frequently applied to implement request timeouts:

function downloadResource() {
  return new Promise((resolve) => {
    const img = new Image();
    img.onload = () => resolve('Resource acquired');
    img.src = 'https://placeholder.test/image.png';
  });
}

function initiateTimeout(limitMs) {
  return new Promise((_, reject) => {
    setTimeout(() => reject('Connection timed out'), limitMs);
  });
}

Promise.race([downloadResource(), initiateTimeout(3000)])
  .then((output) => console.log('Success:', output))
  .catch((err) => console.warn('Failure:', err));

In this configuration, the race concludes immediately upon resource acquisition or timeout expiration. Any slower pending operations continue in the background, but their results are ignored by the race resolution.