Schwierigkeit, ein Javascript-Verhalten zu umschließen und es für später aufzubewahren

Question

Ich steige in die Programmierung mit JavaScript ein und benutze Promises, im Moment benutze ich Q.js. Ich bin endlich an einem Punkt angekommen, an dem ich verstehe, was ich tue, habe aber Schwierigkeiten mit einem bestimmten Verhalten.

Ich habe eine Situation, in der ähnlicher Code mehrmals wiederholt wird. Es läuft im Grunde genommen so ab...

{
   // start
   var deferred = Q.defer();

   // mach etwas {
      deferred.resolve();
   }

   return deferred.promise;
}

Okay, das ist alles gut und schön, aber es wurde mir zu lästig, das jedes Mal zu wiederholen, also habe ich versucht, es in etwas zu verpacken. Dies ist nur ein Beispiel, es ist nicht die gesamte JavaScript-Datei, da die meisten anderen Teile nicht relevant sind.

{
   var list = [];
   queue = function(f) {
      var deferred = Q.defer();
      list.push(f(deferred));
      return deferred.promise;
   }

   {
      queue(function(deferred){
         // mach etwas
         // wir wollen das deferred hier, damit wir es zum richtigen Zeitpunkt auflösen können
         deferred.resolve();
      });
   }
}

Das Problem ist, dass ich nicht möchte, dass dies sofort ausgeführt wird, wenn ich es in die Warteschlange stelle. Ich möchte im Grunde genommen die Liste erstellen und sie dann später ausführen. Ich führe die Liste mit der Funktion reduce in Q.js aus.

{
   return list.reduce(function(i, f) {
      return i.then(f);
   }, Q());
}

Aber das widerspricht irgendwie meinem Ziel, da ich sie wirklich nicht gleichzeitig ausführen möchte, wenn sie in die Warteschlange gestellt werden. Gibt es eine Möglichkeit, die Ausführung für später zu speichern und trotzdem das deferred-Objekt durch die Funktion zu übergeben?

Aktualisierung

Ich wurde gefragt, was ich von dem Code erwarte, was eine berechtigte Frage ist. Ich werde versuchen zu erklären. Der Zweck davon ist, die Logik aufzuteilen, weil ich ASP.NET MVC benutze und daher _Layout-Seiten und normale Ansichten habe - also gibt es Logik, die nicht ausgeführt werden kann, bis andere Dinge abgeschlossen sind, manchmal aber auf Basis einer einzelnen Seite. Diese Methode wurde entwickelt, um damit umzugehen.

Grundsätzlich funktioniert es so...

Loader.js

Das ist, salopp gesagt, ein globales Objekt. Ich habe Pläne, das irgendwann zu ändern, aber step by step.

{
   var Loader = {};
   var list = [];

   initialize = function() {
      Q().then(step1).then(step2).then(process).then(finalStep);
   };

   queue = function(f) {
      // füge die gegebene Funktion der Liste hinzu
   };

   process = function() {
      return list.reduce(function(i,f){ 
         return i.then(f);
      }, Q());
   };

   step1 = function() { // generelles Beispiel
      // erstelle ein Promise
      return deferred.promise;
   }; // Andere Schritte ähneln diesem.

   return Loader;
}

_Layout

   @RenderSection("scripts", false)

      // wir haben das Loader-Objekt bereits
      Loader.initialize();

Index

@section Scripts {

      Loader.promise(function(deferred){
         // mache hier etwas.
         deferred.resolve();
      }));

}

Answer 1

Sie könnten eine closure verwenden.

queue(function(deferred) {
    return function() {
        // Dies ist die tatsächliche Funktion, die ausgeführt wird,
        // aber sie wird Zugriff auf die deferred Variable haben
        deferred.resolve();
    };
});

Answer 2

Ich denke, du solltest etwas Ähnliches tun

var Loader = {
    promise: function(construct) {
        var deferred = Q.defer();
        construct(deferred);
        return deferred.promise;
    },
    queue: function(f) {
        this.ready = this.ready.then(f);
    },
    ready: Q.Promise(function(resolve) {
        window.onload = resolve; // oder was auch immer du hier tun musst
        // oder weise die resolve-Funktion Loader.initialize zu und rufe sie später auf
    })
};

Dann Loader.queue() Funktionen, die andere Versprechen zurückgeben.