promises.js

async function getNumber(number) {
  const name = `getNumber-${number}`

  return new Promise((resolve, reject) => {
    console.log(`---- start ${name}`)
    setTimeout(() => {
      console.log(`------ finish ${name}`)
      resolve(number);
    }, number * 1000);
  });
};


// Output: the functions are executed in parallel
// ---- start getNumber-1
// ---- start getNumber-2
// ---- start getNumber-3
// ------ finish getNumber-1
// ------ finish getNumber-2
// ------ finish getNumber-3
// [ 1, 2, 3 ]
async function example1() {
  const tasks = [1, 2, 3].map(
    async (number) => () => getNumber(number)
  )
  const values = await Promise.all(tasks);
  console.log(values);

}

// Output: the functions are executed in series
// ---- start getNumber-1
// ------ finish getNumber-1
// ---- start getNumber-2
// ------ finish getNumber-2
// ---- start getNumber-3
// ------ finish getNumber-3
// [ 1, 2, 3 ]
async function example2() {
  const values = [
    await getNumber(1),
    await getNumber(2),
    await getNumber(3)
  ]

  console.log(values)
}

// Output: the functions are executed in parallel
// ---- start getNumber-1
// ------ finish getNumber-1
// ---- start getNumber-2
// ------ finish getNumber-2
// ---- start getNumber-3
// ------ finish getNumber-3
// [ 1, 2, 3 ]
async function example3() {
  const tasks = [1, 2, 3].map(
    (number) => ()  => getNumber(number)
  )

  const values = await executeInSeriesAndCollect(tasks)
  console.log(values);
}


// example1();
// example2();
example3();

// this function takes a collection of async functions and execute them one after the other
async function executeInSeriesAndCollect(tasks) {
  const values = []
  let first = true
  const result = await tasks.reduce(
    (promise, task) => promise.then(function (value) {
      if (first) {
        first = false
        return task()
      }
      values.push(value)
      return task()
    }),
    Promise.resolve()
  )
  values.push(result);
  return values;
}

function executeInSeries(tasks) {
  return tasks.reduce(
    (promise, task) => promise.then(task), 
    Promise.resolve()
  )
}