código de ejecución cuando dos eventos han desencadenado

Question

Esto es principalmente una pregunta independiente del idioma.

Si estoy esperando que se lleven a cabo dos eventos (por ejemplo, dos eventos IO o solicitudes http), ¿cuál es el mejor patrón para tratar esto? Una cosa en la que puedo pensar es la siguiente (ejemplo de pseudo js).

request1.onComplete = function() { 
    req1Completed = true; 
    eventsCompleted(); 
} 

request2.onComplete = function() { 
    req2Completed = true; 
    eventsCompleted(); 
} 

eventsCompleted = function() { 

    if (!req1Completed || !req2Completed) return; 
    // do stuff 

} 

¿Es este el patrón más efectivo, o hay formas más elegantes de resolver este problema?

Answer 1

Antes incluso de entrar en los detalles, aquí hay algo limpio que se aprovecha de las funciones lambda de la parte superior de mi cabeza:

function makeCountdownCallback(count, callback) { 
    return function() { 
     if (--count == 0) 
      callback(); 
    }; 
} 

request1.onComplete = request2.onComplete = makeCountdownCallback(2, function() { 
    // do stuff 
}); 

Obviamente, esto supone que cada evento se desencadena como máximo una vez, y no toma ventaja de la orden

Answer 2

jQuery 1.5 tiene Deferreds: http://api.jquery.com/category/deferred-object/

podrá ajustar fácilmente hacia arriba para volver a llamar sólo cuando algunos eventos se han disparado.

Answer 3

Try # 1: He aquí una solución que no requiere variables globales adicionales:

request1.onComplete = function() { 
    // register new handler for event2 here, overwriting the old one 
    request2.onComplete = function() { 
     // now they're both done 
    } 
} 

request2.onComplete = function() { 
    // register new handler for event1 here, overwriting the old one 
    request1.onComplete = function() { 
     // now they're both done 
    } 
} 

El controlador para el que sea activa el evento de primera borrará de edad manejador del otro y asignar una nueva que incluye la cosas que debe hacer después de la finalización de ambos eventos. Debido a que reasignamos el segundo controlador dentro del controlador del primer evento (cualquiera que sea), siempre sabemos que terminamos cuando el segundo controlador finaliza.

Try # 2: Aquí hay algo que va a funcionar si cada tipo de evento es diferente:

function onBoth(fn) { 
    var last, done = false; 
    return function(e) { 
     if (last && last !== e.type && !done) { 
      fn(); // done 
      done = true; 
     } 
     last = e.type; 
    } 
} 

Por ejemplo, esto no le alertará "hecho" cuando el usuario haya tanto desplazado clic:

var both = onBoth(function() { 
    alert("done") 
}); 

document.addEventListener("scroll", both, false); 
document.addEventListener("click", both, false); 

try # 3: El intento anterior puede ser modificado para trabajar por eventos similares:

function onBoth(fn) { 
    var last, done = false; 
    return function(curr) { 
     if (last && last !== curr && !done) { 
      fn(); // done 
      done = true; 
     } 
     last = curr; 
    } 
} 

... que debe ser utilizado de esta manera:

var check = onBoth(function() { 
    alert("done") 
}); 

request1.onComplete = function() { 
    check(arguments.callee); 
} 

request2.onComplete = function() { 
    check(arguments.callee); 
} 

Básicamente, se comprueba que dos devoluciones de llamada diferentes han ejecutado mediante el almacenamiento de una referencia a la llamada más recientemente ejecutado espalda. Su uso es un poco torpe, pero hace el trabajo (es decir, seguirá funcionando si cada uno de los eventos se ejecuta más de una vez).

Answer 4

Una forma de hacerlo: http://tobireif.com/posts/waiting_for_two_events/

Q.spread([ 
    getA(), getB() 
], function(a, b) { 
    // Use the results a and b. 
// Catch errors: 
}).catch(function(error) { 
    // Minimal for this example: 
    console.log(error); 
}); 

El lib está en https://github.com/kriskowal/q.