javascript - trabajar - promise tutorial js

¿Cómo acceder al valor de una promesa?

Question

Estoy viendo este ejemplo de los documentos de Angular por $q pero creo que esto probablemente se aplica a las promesas en general. El siguiente ejemplo se copia literalmente de sus documentos con su comentario incluido:

promiseB = promiseA.then(function(result) {
  return result + 1;
});

// promiseB will be resolved immediately after promiseA is resolved and its value
// will be the result of promiseA incremented by 1

No tengo claro cómo funciona esto. Si puedo llamar a .then() en el resultado del primer .then() , encadenándolos, lo que sé que puedo, entonces promiseB es un objeto de promesa, de tipo Object . No es un Number . Entonces, ¿qué quieren decir con "su valor será el resultado de la promesa A incrementada en 1"?

¿Se supone que debo acceder a eso como valor de promiseB.value o algo así? ¿Cómo puede la devolución de llamada exitosa devolver una promesa Y devolver "resultado + 1"? Me falta algo

Answer 1

Analizar el comentario de forma un poco diferente a su comprensión actual podría ayudar:

// promiseB will be resolved immediately after promiseA is resolved

Esto establece que la promesa promiseB es una promesa, pero se resolverá inmediatamente después de que se resuelva la promesa promiseA Otra forma de ver esto significa que promiseA.then() devuelve una promesa asignada a promiseB .

// and its value will be the result of promiseA incremented by 1

Esto significa que el valor que la promiseA resolvió es el valor que la promiseB recibirá como su valor promiseB :

promiseB.then(function (val) {
  // val is now promiseA''s result + 1
});

Answer 2

Cuando una promesa se resuelve / rechaza, llamará a su controlador de éxito / error:

var promiseB = promiseA.then(function(result) {
   // do something with result
});

El método then también devuelve una promesa: promiseB, que se resolverá / rechazará según el valor de retorno del controlador de éxito / error de promiseA .

Hay tres valores posibles que los controladores de éxito / error de promesaA pueden devolver que afectarán el resultado de promesaB:

1. Return nothing --> PromiseB is resolved immediately, 
   and undefined is passed to the success handler of promiseB
2. Return a value --> PromiseB is resolved immediately,
   and the value is passed to the success handler of promiseB
3. Return a promise --> When resolved, promiseB will be resolved. 
   When rejected, promiseB will be rejected. The value passed to
   the promiseB''s then handler will be the result of the promise

Armado con esta comprensión, puede dar sentido a lo siguiente:

promiseB = promiseA.then(function(result) {
  return result + 1;
});

La llamada entonces devuelve la promesaB inmediatamente. Cuando la promesa A se resuelve, pasará el resultado al controlador de éxito de promesa A. Dado que el valor de retorno es el resultado de la promesa A + 1, el controlador de éxito devuelve un valor (opción 2 anterior), por lo que la promesa B se resolverá de inmediato, y el controlador de éxito de la promesa B pasará el resultado de la promesa A + 1.

Answer 3

En el Node REPL, para obtener una conexión DB que era el valor de una promesa, tomé el siguiente enfoque:

let connection
try {
  (async () => {
    connection = await returnsAPromiseResolvingToConnection()
  })()
} catch(err) {
  console.log(err)
}

La línea con await normalmente devolvería una promesa. Este código se puede pegar en el Node REPL o si se guarda en index.js se puede ejecutar en Bash con

node -i -e "$(< index.js)"

que te deja en el Nodo REPL después de ejecutar el script con acceso a la variable establecida. Para confirmar que la función asincrónica ha regresado, puede registrar la connection por ejemplo, y luego está listo para usar la variable. Por supuesto, uno no querría contar con que la función asincrónica se resuelva aún para cualquier código en el script fuera de la función asincrónica.

Answer 4

Este ejemplo me parece explicativo. Observe cómo la espera espera el resultado y, por lo tanto, pierde la Promesa que se devuelve.

cryA = crypto.subtle.generateKey({name:''ECDH'', namedCurve:''P-384''}, true, ["deriveKey", "deriveBits"])
Promise {<pending>}
cryB = await crypto.subtle.generateKey({name:''ECDH'', namedCurve:''P-384''}, true, ["deriveKey", "deriveBits"])
{publicKey: CryptoKey, privateKey: CryptoKey}

Answer 5

La respuesta de pixelbits es correcta y siempre debe usar .then() para acceder al valor de una promesa en el código de producción.

Sin embargo, hay una manera de acceder al valor de la promesa directamente después de que se haya resuelto utilizando el siguiente enlace interno node.js no admitido:

process.binding(''util'').getPromiseDetails(myPromise)[1]

ADVERTENCIA: process.binding nunca fue diseñado para usarse fuera del núcleo de nodejs y el equipo central de nodejs está buscando activamente desaprobarlo

https://github.com/nodejs/node/pull/22004 https://github.com/nodejs/node/issues/22064

Answer 6

Puede hacerlo fácilmente utilizando un método de espera asíncrono en javascript.

A continuación se muestra un ejemplo de recuperación de un valor de promesa de WebRTC utilizando un tiempo de espera.

function await_getipv4(timeout = 1000) {
    var t1 = new Date();
    while(!window.ipv4) {
        var stop = new Date() - t1 >= timeout;
        if(stop) {
            console.error(''timeout exceeded for await_getipv4.'');
            return false;
        }
    }
    return window.ipv4;
}

function async_getipv4() {
    var ipv4 = null;
    var findIP = new Promise(r=>{var w=window,a=new (w.RTCPeerConnection||w.mozRTCPeerConnection||w.webkitRTCPeerConnection)({iceServers:[]}),b=()=>{};a.createDataChannel("");a.createOffer(c=>a.setLocalDescription(c,b,b),b);a.onicecandidate=c=>{try{c.candidate.candidate.match(/([0-9]{1,3}(/.[0-9]{1,3}){3}|[a-f0-9]{1,4}(:[a-f0-9]{1,4}){7})/g).forEach(r)}catch(e){}}})
    findIP.then(ip => window.ipv4 = ip);
    return await_getipv4();
};

Answer 7

Tal vez este pequeño ejemplo de código mecanografiado le ayudará.

private getAccount(id: Id) : Account {
    let account = Account.empty();
    this.repository.get(id)
        .then(res => account = res)
        .catch(e => Notices.results(e));
    return account;
}

Aquí el repository.get(id) devuelve una Promise<Account> . Lo asigno a la account variable dentro del estado de cuenta.

Answer 8

.then función de promesaB recibe lo que se devuelve de .then función de promesaA.

aquí la promesa A está regresando es un número, que estará disponible como parámetro number en la función de éxito de la promesa B. que luego se incrementará en 1

Answer 9

promiseA devuelve una nueva promesa ( promiseB ) que se resuelve inmediatamente después de que se resuelve la promiseA , su valor es el valor de lo que devuelve la función de éxito dentro de promiseA .

En este caso, la promiseA se resuelve con un valor - result e inmediatamente resuelve la promiseB con el valor del result + 1 .

El acceso al valor de promiseB se realiza de la misma manera que promiseA al resultado de promiseA .

promiseB.then(function(result) {
    // here you can use the result of promiseB
});

Answer 10

promiseA(pram).then(
     result => { 
     //make sure promiseA function allready success and response
     //do something here
}).catch(err => console.log(err)) => {
     // handle error with try catch
}