javascript - termine - ¿Cuándo debo rechazar una promesa?

promesas javascript

Question

Estoy escribiendo un código JS que usa promesas. Por ejemplo, abro una ventana emergente de formulario y devuelvo un objeto Aplazado jQuery . Funciona así:

• Si el usuario hace clic en Aceptar en el formulario y lo valida, el Aplazado se resuelve en un objeto que representa los datos del formulario.

• Si el usuario hace clic en Cancelar, el Aplazado se resuelve en un nulo.

Lo que estoy tratando de decidir es si el Aplazado en lugar de rechazar, en lugar de resolver? De manera más general, me pregunto ¿cuándo debo resolver algo como un objeto nulo y cuándo debo rechazar?

Aquí hay un código que demuestra las dos posiciones:

// Resolve with null.
var promise = form.open()
    .done(function (result) {
        if (result) {
            // Do something with result.
        } else {
            // Log lack of result.
        }
    });

// Reject.
var promise = form.open()
    .done(function (result) {            
        // Do something with result.            
    })
    .fail(function () {
        // Log lack of result.
    });

Answer 1

Bueno, en ambos casos harías algo diferente, así que diría que siempre lo resuelves o lo rechazas. Haga su forma de publicación en la resolución, y en el rechazo no hacer nada. Entonces, en siempre, cierra el formulario.

var promise = form.open()
.done(function (result) {            
    // Do something with result.            
})
.fail(function () {
    // Log lack of result.
})
.always(function() {
    // close the form.
})

Si no está rechazando en cancelar, ¿cuándo rechazará en absoluto? En ese punto, ¿por qué usar un objeto diferido? Podría rechazar en el error de entrada, pero luego tendría que generar una promesa completamente nueva si desea permitirles que lo corrijan.

Los diferidos realmente no parecen ser lo correcto para usar aquí. Yo solo uso eventos.

Answer 2

La semántica de sus dos estrategias no es realmente la misma. Rechazar explícitamente un aplazado es significativo.

Por ejemplo, $.when() seguirá acumulando resultados siempre que los objetos diferidos a los que se pasa tengan éxito, pero se rescatarán en el primero que falle.

Significa que, si cambiamos el nombre de sus dos promesas promesas1 y promesas2 respectivamente:

$.when(promise1, promise2).then(function() {
    // Success...
}, function() {
    // Failure...
});

El código anterior esperará hasta que se cierre el segundo formulario, incluso si se cancela el primer formulario, antes de invocar una de las devoluciones de llamada pasadas a then() . La devolución de llamada invocada (éxito o fracaso) solo dependerá del resultado del segundo formulario.

Sin embargo, ese código no esperará a que se cierre el primer formulario antes de invocar la devolución de llamada de error si se cancela el segundo formulario.

Answer 3

Ya que es controlado por el usuario, no lo trataría como un "error". La primera opción parece más limpia.