Demander une confirmation au milieu d'un processus

Question

Je cherche une bonne approche pour parfois mettre en pause une action (fonction/appel de méthode) jusqu'à ce que l'utilisateur confirme qu'il veut faire une partie spécifique de cette action. Je dois le faire dans un environnement qui ne permet pas l'arrêt de l'exécution de code (ActionScript dans mon cas, mais une approche pour JavaScript doit être identique).

Pour illustrer, ceci est une maquette de l'action avant d'introduire l'invite utilisateur:

<preliminary-phase> // this contains data needed by all the following phases // 

<mandatory-phase> // this will be always be executed // 

<optional-phase> // this will always execute too, if in this form, but in some cases we need to ask the user if he wants to do it // 

<ending-phase> // also mandatory // 

Ce que j'ai besoin est d'insérer une invite utilisateur conditionnel, un « Voulez-vous faire cette partie? ", et faire <optional-phase> seulement si l'utilisateur veut.

<preliminary-phase> 

<mandatory-phase> 

if(<user-confirmation-is-needed> and not <user-response-is-positive>){ 
    <do-nothing> 
} 
else{ 
    <optional-phase> 
} 

<ending-phase> 

Lorsque vous essayez de le faire dans ActionScript/JavaScript Je suis quelque chose comme ceci:

<preliminary-phase> 

<mandatory-phase> 

if(<user-confirmation-is-needed>){ 
    askForConfirmation(callback = function(){ 
     if(<user-response-is-positive>) 
      <optional-phase> 
     <ending-phase> 
    }); 
    return; 
} 

<optional-phase> 

<ending-phase> 

Maintenant, les deux <optional-phase> et <ending-phase> sont dupliquées. Aussi parce qu'ils utilisent des objets créés dans <preliminary-phase> je ne peux pas les déplacer vers des fonctions externes sans passer toutes les données à ces fonctions.

Ma solution actuelle est que je joint chacun des <optional-phase> et <ending-phase> dans certaines fonctions locales (afin qu'ils aient accès aux données <preliminary-phase>) déclarés avant que je demande confirmation et j'appeler ces fonctions au lieu de dupliquer le code, mais il ne semble pas correct que le code ne soit plus dans l'ordre où il est exécuté.

Que recommanderiez-vous? Remarques:
1. askForConfirmation est une fonction non bloquante. Cela signifie que le code qui suit son appel est exécuté immédiatement (c'est pourquoi j'ai un return; dans mon approche).

Answer 1

Note: Je ne suis pas 100% sûr que je reçois vos circonstances exactes.

Le motif de commande peut convenir ici. C'est semblable à ce que les gens suggèrent.

Vous avez un tableau de commandes qui sont exécutées dans l'ordre. Décalez simplement les commandes de la baie une par une et appelez la méthode d'exécution.

Dans la phase facultative, vérifiez si la confirmation de l'utilisateur est requise, sinon exécutez une méthode de code optionnelle qui distribue un événement de commande terminée, si nécessaire, affichez l'alerte, attendez un événement, vérifiez Le résultat et soit l'envoi d'un événement complete de commande ou appelez la méthode optionnelle (qui s'exécutera puis enverra une commande complète).

Vous pouvez également créer un arbre de commandes afin de pouvoir indiquer clairement le déroulement de l'exécution sans avoir à manipuler le tableau.

Voici comment les programmes tels que les assistants d'installation fonctionnent.

Il est bon que l'ordre d'exécution soit agréable et visible et que votre code soit bien décomposé en morceaux, et que la complexité de chaque étape soit encapsulée. Par exemple, la phase optionnelle ne sait rien de la phase de fin. La phase optionnelle sait seulement que l'utilisateur peut avoir besoin d'une invite avant l'exécution et il gère tout cela en interne.

http://en.wikipedia.org/wiki/Command_pattern

« Utilisation des objets de commande facilite la construction de composants généraux qui doivent déléguer, séquence ou exécuter des appels de méthode à un moment de leur choix ... »

Answer 2

"le code n'est plus dans l'ordre où il est exécuté" me semble bien. C'est bien d'avoir du code qui n'est pas écrit dans l'ordre où il est exécuté tant qu'il est clair. En fait, puisque votre code s'exécute dans des ordres variables, je pense qu'il est impossible pour vous de l'écrire dans l'ordre qu'il va exécuter sans dupliquer le code, ce qui est un bien plus grand mal. Choisissez de bons noms de fonctions et votre approche passerait mon examen de code.

<preliminary-phase> 

<mandatory-phase> 

var optional_phase = function() { 
    <optional-phase> 
} 

var ending_phase = function() { 
    <ending-phase> 
} 

if(<user-confirmation-is-needed>){ 
    askForConfirmation(function(){ 
     if(<user-response-is-positive>) 
      optional_phase(); 
     ending_phase(); 
    }); 
    return; 
} 

optional_phase(); 
ending_phase(); 

Answer 3

Est-ce que ce que vous demandez?

<preliminary-phase> 

<mandatory-phase> 

if(<user-confirmation-is-needed>){ 
    askForConfirmation(function(){ 
     if(<user-response-is-positive>) 
      <optional-phase-as-local-function> 
     <ending-phase-as-local-function> 
    }); 
} else { 
    <optional-phase-as-local-function> 
    <ending-phase-as-local-function> 
} 

Answer 4

Pas un énorme changement, mais à condition que cela fonctionne le flux, la phase facultative ne se répète pas

<preliminary-phase> 

<mandatory-phase> 

if(<user-confirmation-is-needed>){ 
    askForConfirmation(function(){ 
     if(<user-response-is-negative>) 
     { 
     <ending-phase> 
     return; 
     } 
    }); 
} 

<optional-phase> 
<ending-phase>