Noções básicas sobre assíncrono, espera, promessa do TypeScript (artigo 1)

 

Sem mais delongas, o código anterior:

Entenda a sintaxe básica do assíncrono e aguarde

O valor retornado pela instrução de retorno dentro da função assíncrona se tornará o parâmetro da função de retorno de chamada do método then

Um erro lançado dentro da função assíncrona fará com que o objeto Promise retornado seja
rejeitado e o objeto de erro lançado será recebido pelo método de retorno de chamada do método catch

função getData () {
     return "syy" ; 
} 

console.log (getData ());  // função syy 

async getData2 () {
     return "syy2" ; 
} 
console.log (getData2 ());  // Promessa {resolvida} 
//  
getData2 (). Then (data => {console.log (data)});  // syy2

 

 

 

interface TEST_TYPE { 
    nome: string, 
    idade: número 
} 
deixe testA = <TEST_TYPE> { 
    nome: "henry" , 
    idade: 666 
} 

função changeA (testA: TEST_TYPE) 
{ 
    testA.age = 777 ;
 //     lança novo erro ("changeA new a error ");   
    return testA; // // presta atenção especial aos dados retornados, capturamos no exterior então ... incluindo exceções 
} 
função 
assíncrona testAsync (testA: TEST_TYPE) 
{ 
//     lança novo erro (" testAsync new a error. ") 
    deixe testB = aguardar changeA (testA);
 //    testB.age = 333; 
    testB.name = "明天 要 交作业" ;
    retornar testB;
//     retorna testA; 
} 

const resultado1 = testAsync (testA); 
resultado1 .then 
(retValue => { 
    console.log (retValue); 
    console.log (retValue.name); 
    console.log (retValue.age);}, 
    rejeitar => { 
        console.log ( "rejeitar. Deve ser algum erro acontecer " ); 
        console.log (rejeitar); 
    } 
). pegar (err => { 
    console.log ( "pegar algum erro." );
    console.log (err); 
});

 

Aqui está um exemplo para entender como o programa funciona

função assíncrona suspensão (intervalo: número) {
     retornar  nova promessa (resolução => { 
      setTimeout (resolução, intervalo); 
    }) 
    .then (resolve2 => {console.log ("concluir a resolução2." )}}, 
      rejeitar2 => {console .log ("reject2" )}); 
} 
  função 
assíncrona one2XInAsync (intervalo: número = 100 ) {
     for (deixe i = 1; i <= intervalo; i ++ ) { 
        console.log ( "one2FiveInAsync: -----------" + i);
        if (i == 3 ) 
        { 
        lança  novo erro ("i == 3 break" );
        } 
        aguarde o sono ( 2000 ); 
    } 
} 
  
one2XInAsync ( 20 ) 
  .then (resolve3 => { 
    console.log ( "resolv3" ); 
    console.log (resolve3); 
  }, rejeite3 => { 
    console.log ( "reject3" ); 
    console.error (reject3) ; 
});

 

Continue colando um pedaço de código

deixe testNum = 1 + 1 ;
função takeLongTime () {
     retorna  nova promessa (resolve => { 
        setTimeout (() => { 
            resolve ( "Hello world" ); 
        }, 4000 ); 
    }); 
} 
função 
assíncrona test1 () { 
    deixe t1 = aguardar takeLongTime (); 
    console.log (testNum); 
    console.log (t1); 
} 
test1 ();

 

 

Uma única cadeia Promise não pode encontrar as vantagens de assíncrono / espera, mas se você precisar lidar com uma cadeia then composta de várias promessas, as vantagens poderão ser refletidas (de maneira interessante, o Promise usa a cadeia then para resolver o problema de retornos de chamada em várias camadas E agora use async / waitit para otimizá-lo ainda mais).

Suponha que um negócio seja concluído em várias etapas, cada etapa é assíncrona e depende do resultado da etapa anterior. Ainda usamos setTimeout para simular operações assíncronas:

função takeLongTime (n: número) {
     retorna  nova promessa (resolve => { 
        setTimeout (() => resolve (n + 1000 ), n); 
    })); 
} 

função step1 (n: number) { 
    console.log (`step1 com $ {n}`);
    retornar takeLongTime (n); 
} 

função step2 (n: number) { 
    console.log (`step2 com $ {n}`);
    retornar takeLongTime (n); 
} 

função step3 (n: number) { 
    console.log (`step3 com $ {n}`);
    retornar takeLongTime (n); 
}


/ * * 采用 Promise 实现* / 
function doIt1 () { 
    console.time ( "doIt1" ); 
    const time1 = 300 ; 
    Passo 1 (time1) 
        .then (time2 => step2 (<número> time2)) 
        .then (time3 => passo3 (<número> time3)) 
        .then (result => { 
            console.log (o resultado é $ {result}) `); 
            console.timeEnd ( " doIt " ); 
        }); 
} 

DoIt1 (); 
// etapa1 com 300 
// etapa2 com 1300 
// etapa3 com 2300 
//o resultado é 3300 
// doIt: 3908.552001953125ms 
// doIt: 3908.640ms 
função 


assíncrona doIt2 () { 
    console.time ( "doIt2" ); 
    const time1 = 400 ; 
    const time2 = aguarda etapa1 (time1); 
    const time3 = aguarde etapa2 (<número> time2); 
    const resultado = aguardar etapa3 (<número> tempo3); 
    console.log (`resultado é $ {resultado}`); 
    console.timeEnd ( "doIt2" ); 
} 
doIt2 (); // etapa1 com 400 
// etapa2 com 1400 
// etapa3 com 2400


// resultado é 3400 
// doIt2: 4211.223876953125ms 
// doIt2: 4212.416ms