javascript - trabajar - promise tutorial js
¿Cómo acceder al valor de una promesa? (10)
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
});
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
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.
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.
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}
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
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();
};
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.
.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
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
});
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
}