Question

EDIT

Let me get more to the point. I’m trying to create a psuedo promise implementation. The idea here being that I have a callback that won’t be executed until an asynchronous call is received. So I’m simply queueing up all the calls to this function until the time at which it’s notified that it can be executed. The queue is emptied and any further call to the function is SUPPOSED to execute immediately, but for some reason, the function is still queueing. This is because, for whatever reason, my redefinition of the runner function is not working correctly. The code below was my sleep deprived, frustrated version of every thought that went through my head. Here’s the actual code:

function Promise(callback){
  var queue    = []
    , callback = callback
    , runner   = function(){
        queue.push({
          context: this,
          args: Array.prototype.slice.call(arguments, 0)
        });
      }
  ;//var

  runner.exec = function(){
    for(var i = 0, ilen = queue.length; i < ilen; i++){
      var q = queue[i];

      callback.apply(q.context, q.args);
    }

    runner = callback;
  };

  return runner;
}

test = Promise(function(){
  $('<div/>').appendTo('#output').html(Array.prototype.slice.call(arguments,0).toString());
});

test(1,2);
test(3,4);
test.exec();
test(5,6);​

http://jsfiddle.net/a7gaR/

---

I’m banging my head against the wall with this one. I’m trying to reassign variables in a function from a call outside the function itself (ideally by passing a reassignment function as a callback). In the example I posted on jsfiddle, I made a global function that, in theory, has a reference to the variables contained within its parent function. Upon calling that external function, I expect it to reassign the values that the other function is using. It doesn’t seem to work this way.

window.test = function temp() {
    var val = 7,
        func = function() {
            return val;
        };

    window.change = function() {
        window.test.val = 555555;
        $('<div>Changing ' + val + ' to ' + window.test.val + 
               '</div>').appendTo($output);
        val = window.test.val;
        temp.val = window.test.val;
        func = function() {
            return 'Why isn\'t this working?';
        }
    }

    return func();
}

var $output = $('#output');

$('<div/>').appendTo($output).html('::' + test() + '::');
window.change();
$('<div/>').appendTo($output).html('::' + test() + '::');

http://jsfiddle.net/YhyMK/

Answer 1

I finally created a function that would perform this operation. The gist for it is here: https://gist.github.com/2586972.

It works like this…

You make a call to Defer passing the callback whose functionality you’d like to delay:

var deferredCB = Defer(function(){ console.log(this,arguments) };

deferredCB will now store all of the arguments you pass allowing them to be executed at some later date:

defferedCB(1);
defferedCB(2);

Now, when you’re ready to perform the operation, you simply “execute” deferredCB:

defferedCB.exec();

Which results in:

// window, 1
// window, 2

All future calls to deferredCB will be executed immediately. And now that I’m thinking about it, I’ll probably do a rewrite to allow you to reset deferredCB to it’s pre-executed state (storing all the arguments again).

The key to making it work was having a wrapper function. Javascript simply won’t let you reassign a function while it’s being executed.

TADA!!!