promesas - promises javascript ajax
¿Pueden las promesas tener múltiples argumentos para onFulfilled? (8)
Estoy siguiendo las especificaciones aquí y no estoy seguro de si permite que se llame a Fully con múltiples argumentos.
No, solo el primer parámetro se tratará como valor de resolución en el constructor de promesa. Puede resolver con un valor compuesto como un objeto o matriz.
No me importa cómo lo hace una implementación de promesas específica. Deseo seguir de cerca las especificaciones de w3c.
Ahí es donde creo que estás equivocado. La especificación está diseñada para ser mínima y está construida para interoperar entre bibliotecas prometedoras. La idea es tener un subconjunto que los futuros de DOM, por ejemplo, puedan usar confiablemente y las bibliotecas puedan consumir. Las implementaciones .spread hacen lo que piden con. .spread desde hace un tiempo. Por ejemplo:
Promise.try(function(){
return ["Hello","World","!"];
}).spread(function(a,b,c){
console.log(a,b+c); // "Hello World!";
});
Con Bluebird . Una solución si quieres esta funcionalidad es rellenarla.
if (!Promise.prototype.spread) {
Promise.prototype.spread = function (fn) {
return this.then(function (args) {
return Promise.all(args); // wait for all
}).then(function(args){
//this is always undefined in A+ complaint, but just in case
return fn.apply(this, args);
});
};
}
Esto te permite:
Promise.resolve(null).then(function(){
return ["Hello","World","!"];
}).spread(function(a,b,c){
console.log(a,b+c);
});
Con promesas nativas a gusto fiddle . O use spread, que ahora es (2018) un lugar común en los navegadores:
Promise.resolve(["Hello","World","!"]).then(([a,b,c]) => {
console.log(a,b+c);
});
O con la espera:
let [a, b, c] = await Promise.resolve([''hello'', ''world'', ''!'']);
Estoy siguiendo las especificaciones here y no estoy seguro de si permite que se llame a Fully con múltiples argumentos. Por ejemplo:
promise = new Promise(function(onFulfilled, onRejected){
onFulfilled(''arg1'', ''arg2'');
})
tal que mi código:
promise.then(function(arg1, arg2){
// ....
});
recibiría tanto arg1 como arg2 ?
No me importa cómo lo hace una implementación de promesas específica. Deseo seguir de cerca las especificaciones de w3c.
Como se pueden invocar funciones en Javascript con cualquier cantidad de argumentos, y el documento no impone ninguna restricción sobre los argumentos del método onFulfilled () además de la cláusula siguiente, creo que puede pasar múltiples argumentos al método onFulfilled () siempre que como el valor de la promesa es el primer argumento.
2.2.2.1 it must be called after promise is fulfilled, with promise’s value as its first argument.
El valor de cumplimiento de una promesa es paralelo al valor de retorno de una función y el motivo de rechazo de una promesa es paralelo a la excepción lanzada de una función. Las funciones no pueden devolver valores múltiples por lo que las promesas no deben tener más de 1 valor de cumplimiento.
En lo que respecta a la lectura de la especificación ES6 Promise y la especificación de promesa estándar, no hay ninguna cláusula que impida que una implementación maneje este caso; sin embargo, no se implementa en las siguientes bibliotecas:
Supongo que la razón por la que omiten resoluciones multi arg es hacer que el cambio de orden sea más breve (es decir, como solo puede devolver un valor en una función, haría que el flujo de control fuera menos intuitivo) Ejemplo:
new Promise(function(resolve, reject) {
return resolve(5, 4);
})
.then(function(x,y) {
console.log(y);
return x; //we can only return 1 value here so the next then will only have 1 argument
})
.then(function(x,y) {
console.log(y);
});
Estoy buscando la misma solución y encontré algo muy interesante de esta respuesta: rechazo de promesas con múltiples argumentos (como $ http) en AngularJS
la respuesta de este tipo Florian
promise = deferred.promise
promise.success = (fn) ->
promise.then (data) ->
fn(data.payload, data.status, {additional: 42})
return promise
promise.error = (fn) ->
promise.then null, (err) ->
fn(err)
return promise
return promise
Y para usarlo:
service.get().success (arg1, arg2, arg3) ->
# => arg1 is data.payload, arg2 is data.status, arg3 is the additional object
service.get().error (err) ->
# => err
Gran pregunta y gran respuesta de Benjamin, Kris, et al. ¡Muchas gracias!
Estoy usando esto en un proyecto y he creado un módulo basado en el código de Benjamin Gruenwald . Está disponible en npmjs:
npm i -S promise-spread
Luego, en tu código, hazlo
require(''promise-spread'');
Si está usando una biblioteca como any-promise
var Promise = require(''any-promise'');
require(''promise-spread'')(Promise);
¡Quizás otros encuentren esto útil también!
Para citar el artículo siguiente, "" luego "toma dos argumentos, una devolución de llamada para un caso de éxito y otro para el caso de falla. Ambos son opcionales, por lo que puede agregar una devolución de llamada solo para el caso de éxito o error".
Por lo general, miro a esta página por cualquier pregunta básica sobre promesas, avíseme si me equivoco.
Puedes usar la desestructuración E6:
Destructuración de objetos:
promise = new Promise(function(onFulfilled, onRejected){
onFulfilled({arg1: value1, arg2: value2});
})
promise.then(({arg1, arg2}) => {
// ....
});
Array desestructuración:
promise = new Promise(function(onFulfilled, onRejected){
onFulfilled([value1, value2]);
})
promise.then(([arg1, arg2]) => {
// ....
});