async-await.md


// Build a Promise that performs 4 asynchronous computations in sequence
promiseA
  .then(a => { /* build and return promiseB... */ })
  .then(b => { /* build and return promiseC... */ })
  .then(c => { /* build and return promiseD... */ })
// Build a promise that performs 3 asynchronous computations in parallel
// and resolves with their results once they have all finished
Promise.all([promiseA, promiseB, promiseC])
async function name(...arguments) {
  /* ... */
}
// or
async (...arguments) => { /* ... */ }
// Returns a Promise<number> that computes the most recent
// modification time for any file inside a directory
async function modifiedTime(path) {
  // First, we wait for the fs.stat() Promise
  const stats = await fs.stat(path)
  // Use the modification time of the file or directory itself
  let latestTime = stats.mtimeMs
  // If this is a directory, check all files inside for later modified times
  if (stats.isDirectory()) {
    // Wait to get a list of all files/subdirectories in the directory
    const files = await fs.readdir(path)
    // Then get the modified time of each file/subdirectory
    for (const file of files) {
      const fileModifiedTime = await modifiedTime(path + '/' + file)
      // update latestTime if the modification time is later
      latestTime = Math.max(latestTime, fileModifiedTime)
    }
  }
  // Return the latest modification time
  return latestTime
}
async function modifiedTime(path) {
  const stats = await fs.stat(path)
  const {mtimeMs} = stats
  // If this path is a file, return its modification time
  if (!stats.isDirectory()) return mtimeMs

  // If this is a directory, check all files inside for later modified times
  const files = await fs.readdir(path)
  // Get the modified time of each file/subdirectory in parallel
  const modifiedTimes = await Promise.all(files.map(file =>
    modifiedTime(path + '/' + file)
  ))
  // Return the latest modification time
  return Math.max(mtimeMs, ...modifiedTimes)
}
async function getUnicodeNumber(searchName) {
  // Fetch the readme to determine the latest Unicode version (e.g. 13.0.0)
  const readmeResponse = await fetch(README_URL)
  const readme = await readmeResponse.text() // read readme as a string
  // The last line of the readme contains the current Unicode URL,
  // e.g. https://www.unicode.org/Public/13.0.0/ucd/
  const [latestURL] = readme.trim().split('\n').slice(-1)

  // Then fetch the list of Unicode characters
  const charactersResponse = await fetch(latestURL + UNICODE_FILE)
  const charactersData = await charactersResponse.text()
  // Each line of the data file corresponds to one Unicode character
  for (const characterData of charactersData.split('\n')) {
    // Each line has several fields separated by `;`.
    // The first is the character's number and the second is its name.
    const [characterNumber, characterName] = characterData.split(';')
    if (characterName.toLowerCase() === searchName) {
      // If this is the requested character, read its number in base-16
      return parseInt(characterNumber, 16)
    }
  }
  return undefined
}

async function printUnicode(searchName) {
  // getUnicodeNumber() returns a Promise, so we need to await it
  const number = await getUnicodeNumber(searchName)
  // Convert the Unicode number to a character
  if (number !== undefined) console.log(String.fromCodePoint(number))
}
// Creates an array of files. If any file already exists,
// no files are created and an error is thrown.
async function writeFiles(files) {
  for (let i = 0; i < files.length; i++) {
    const file = files[i]
    try {
      // Write to the file, but throw an error if the file exists
      await fs.writeFile(file.name, file.contents, {flag: 'wx'})
    }
    catch (e) {
      // File already exists, so remove all the previously created files
      await Promise.all(files.slice(0, i).map(file =>
        fs.unlink(file.name)
      ))
      // Re-throw the error
      throw e
    }
  }
}

// Try to create 3 files
writeFiles([
  {name: 'a.txt', contents: 'abc'},
  {name: 'b.txt', contents: '123'},
  {name: 'c.txt', contents: 'xyz'}
])
  .catch(_ => console.log('Some files already existed'))