typescript 异步/等待

Posted 2021-05-20

//Standart
function awaitDelayed() : Promise<void> {
return new Promise<void> (
( resolve: () => void,
reject: () => void ) =>
{
function afterWait() {
console.log(`wywołujemy funkcję zwrotną resolve`);
resolve();
}
setTimeout(afterWait, 1000);
}
);
}

/  słowa kluczowe async i await
//  ===========

function awaitDelayed() : Promise<void> {
  return new Promise<void> (
    ( resolve: () => void,
      reject: () => void ) => 
      {
        function afterWait() {
          console.log(`wywołujemy funkcję zwrotną resolve`);
          resolve();
        }    
        setTimeout(afterWait, 1000);
      }
  );
}

async function callAwaitDelayed() {
  console.log(`wywołujemy funkcję awaitDelayed`);
  await awaitDelayed();
  console.log(`po wywołaniu funkcji awaitDelayed`);
}

callAwaitDelayed();


//  słowo kluczowe async i obsługa błędów
//  ============

function awaitError() : Promise<string> {
  return new Promise<string> (
    ( resolve: (message: string) => void,
      reject: (error: string) => void ) => 
      {
       function afterWait() {
         console.log(`wywołujemy metodę zwrotną reject`);
         reject("wystąpił błąd");
       }    
       setTimeout(afterWait, 1000);
      }
  );
}

async function callAwaitError() {
  console.log(`wywołujemy funkcję awaitError`);
  try {
    await awaitError();
  } catch (error) {
    console.log(`zwrócono błąd : ${error}`);
  }
  console.log(`po wywołaniu funkcji awaitDelayed`);
}

callAwaitError();


function simplePromises() {
  // wywołanie funkcji asynchronicznej
  delayedPromise().then(
    () => { 
      // kod wykonywany w razie prawidłowego
      // wyznaczenia obietnicy
    }
  ).catch (
    () => {
      // kod wywoływany w razie wystąpienia błędu
    }
  );
  // kod umieszczony w tym miejscu NIE będzie
  // czekał na zakończenie wykonywania funkcji asynchronicznej
}

async function usingAsyncSyntax() {
  try {
    await delayedPromise();
    // kod wykonywany w razie pomyślnego wyznaczenia obietnicy
  } catch(error) {
    // kod wykonyway w przypadku, gdy podczas wyznaczania 
    // obietnicy wystąpiły jakieś błędy
  }
  // ten kod zostanie wykonany dopiero po zakończeniu 
  // funkcji asynchronicznej
}


function asyncWithMessage() : Promise<string> {
  return new Promise<string> (
    ( resolve: (message: string ) => void,
      reject: (message: string) => void
    ) => {
      function afterWait() {
        resolve("komunikat_wyznaczenia_obietnicy");
      }
      setTimeout(afterWait, 1000);
    }
  );
}


async function awaitMessage() {
  console.log(`wywołujemy funkcję asyncWithMessage`);
  let message: string = await asyncWithMessage();
  
  console.log(`zwrócono komunikat: ${message}`);
}

awaitMessage();

//*/