Comprender la sincronización, espera y promesa de TypeScript (artículo 1)

 

Sin más preámbulos, el código anterior:

Comprender la sintaxis básica de async y esperar

El valor devuelto por la declaración return dentro de la función asíncrona se convertirá en el parámetro de la función de devolución de llamada del método

Un error arrojado dentro de la función asincrónica hará que el objeto Promesa devuelto sea
rechazado , y el objeto de error arrojado será recibido por la devolución de llamada del método catch

función getData () {
     return "syy" ; 
} 

console.log (getData ());  // función syy 

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

 

 

 

interfaz TEST_TYPE { 
    nombre: cadena, 
    edad: número 
} 
let testA = <TEST_TYPE> { 
    name: "henry" , 
    age: 666 
} 

function changeA (testA: TEST_TYPE) 
{ 
    testA.age = 777 ;
 //     arroja un nuevo error ("changeA nuevo un error ");   
    return testA; // // presta especial atención a los datos devueltos, 
capturamos en el externo entonces ... incluidas las excepciones } 
función 
asincrónica testAsync (testA: TEST_TYPE) 
{ 
//     arroja un nuevo error (" testAsync new a error ".) 
    deje que testB = aguarde el cambio A (testA);
 //    testB.age = 333; 
    testB.name = "明天 要 交作业" ;
    prueba de retorno B;
//     return testA; 
} 

const result1 = testAsync (testA); 
resultado1 
.then (retValue => { 
    console.log (retValue); 
    console.log (retValue.name); 
    console.log (retValue.age);}, 
    rechazar => { 
        console.log ( "rechazar. Debe ser algo error " ); 
        console.log (rechazar); 
    } 
). catch (err => { 
    console.log ( "captura algún error".  );
    console.log (err);
});

 

Aquí hay un ejemplo para entender cómo funciona el programa.

función asíncrona sleep (intervalo: número) {
     return  new Promise (resolve => { 
      setTimeout (resolve, intervalo); 
    }) 
    .then (resolve2 => {console.log ("terminar resolve2." )}, 
      rechazar2 => {consola .log ("rechazar2" )}); 
} 
  función 
asincrónica one2XInAsync (intervalo: número = 100 ) {
     para (let i = 1; i <= intervalo; i ++ ) { 
        console.log ( "one2FiveInAsync: -----------" + i);
        if (i == 3 ) 
        { 
        lanzar un  nuevo error ("i == 3 break" );
        } 
        aguarda el sueño ( 2000 ); 
    } 
} 
  
one2XInAsync ( 20 ) 
  .then (resolve3 => { 
    console.log ( "resolve3" ); 
    console.log (resolve3); 
  }, rechazar3 => { 
    console.log ( "rechazar3" ); 
    console.error (rechazar3) ; 
});

 

Continuar pegando un trozo de código

deje testNum = 1 + 1 ;
función takeLongTime () {
     return  new Promise (resolve => { 
        setTimeout (() => { 
            resolve ( "Hola mundo" ); 
        }, 4000 ); 
    }); 
} 
función 
asíncrona test1 () { 
    let t1 = await takeLongTime (); 
    console.log (testNum); 
    console.log (t1); 
} 
prueba1 ();

 

 

Una sola cadena de Promise no puede encontrar las ventajas de async / wait, pero si necesita lidiar con una cadena compuesta de múltiples promesas, las ventajas pueden reflejarse (curiosamente, Promise usa la cadena de entonces para resolver el problema de las devoluciones de llamada de múltiples capas , Y ahora use async / await para optimizarlo aún más).

Supongamos que un negocio se completa en varios pasos, cada paso es asíncrono y depende del resultado del paso anterior. Todavía usamos setTimeout para simular operaciones asincrónicas:

función takeLongTime (n: número) {
     return  new Promise (resolve => { 
        setTimeout (() => resolve (n + 1000 ), n); 
    }); 
} 

función paso1 (n: número) { 
    console.log (`paso1 con $ {n}`);
    return takeLongTime (n); 
} 

función step2 (n: número) { 
    console.log (`step2 con $ {n}`);
    return takeLongTime (n); 
} 

función step3 (n: número) { 
    console.log (`step3 con $ {n}`);
    return takeLongTime (n); 
}


/ * * 采用 Promesa 方式 实现* / 
function doIt1 () { 
    console.time ( "doIt1" ); 
    tiempo constante 1 = 300 ; 
    step1 (time1) 
        .then (time2 => step2 (<number> time2)) 
        .then (time3 => step3 (<number> time3)) 
        .then (result => { 
            console.log (`result is $ {result} `); 
            console.timeEnd ( " doIt " ); 
        }); 
} 

doIt1 (); 
// paso1 con 300 
// paso2 con 1300 
// paso3 con 2300 
//el resultado es 3300 
// doIt: 3908.552001953125ms 
// doIt: 3908.640ms 
función 


asincrónica doIt2 () { 
    console.time ( "doIt2" ); 
    tiempo de constante1 = 400 ; 
    const time2 = espera paso1 (time1); 
    const time3 = espera paso2 (<número> tiempo2); 
    resultado constante = espera paso3 (<número> tiempo3); 
    console.log (`el resultado es $ {resultado}`); 
    console.timeEnd ( "doIt2" ); 
} 
doIt2 (); // paso1 con 400 
// paso2 con 1400 
// paso3 con 2400


// el resultado es 3400 
// doIt2: 4211.223876953125ms 
// doIt2: 4212.416ms