Loop Control Module

Reentrant setTimeout() within Object constructor

The setup:

  loop = function() {
    id = setTimeout(
      function() {
        loop();
        client( this );
      },
     delay
    );
  }

Crockford says: var that=this; "...to make the object available to the private methods. This is a workaround for an error in the ECMAScript Language Specification which causes 'this' to be set incorrectly for inner functions."

(At first pass, I would prefer var scope=this within a constructor function, as a more meaningful moniker for someone coming from a C++ class development background. But that's still not quite right.)

this context object

In JS, this points to the context in which a function executes, which just happens to be as expected within an object constructor function. If a method is passed around (a callback), the original context gets lost. Because the constructor product is fundamentally an Object, not a function scope, I settled on var self=this in the one necessary case that I identify.

(A number of Crockford's criticisms of the JS language seem to be stemming from an effort to force C++ class paradigms onto JS. These simple workarounds are muddling the true differences between the languages, and the internet is flooded with thousands of articles, tutorials and QA pages trying to clarify.)

Memory Efficiency versus Privacy

To solve the broken closure in the setup above, we should take into account the purpose and performance requirements of the specific class being defined.

The flexibility of JS syntax permits a myriad tradeoffs to be considered in planning Object instantiation. These include efficiency for large numbers of Objects, and privacy for security and reliability of modules.

A third and frequently important priority is simplicity, for ease of writing and understanding, typically less efficient and less secure.

Easy

  this.loop = function() {
    id = setTimeout(
      function() {
        this.loop();
        client( this );
      }.bind( this ),
      delay
    );
  }

Compact

  Cf.prototype.loop =
  function(){
    this.id = setTimeout(
      function() {
        this.loop();
        this.client( this );
      }.bind( this ),
      this.delay
    );
  };

Secure

  var self = this;
  function loop() {
    id = setTimeout(
      function() {
        loop();
        client( self );
      },
      delay
    );
  }

IIFE class prototype

Showing details of the loop method within its containing class structure:

  function Cf( delay, client ) {
    this.delay = delay;
    this.client = client;
    this.id = 0;
  }

  Cf.prototype = (function() {
    function loop() {
      this.id = setTimeout(
        function() {
          loop.call( this );
          this.client( this );
        }.bind( this ),
        this.delay
      );
    }
    function control() {
      ... control logic
        loop.call( this );
    }
    return {
      control: control
    };
  })();

  var i = new Cf( args );
  i.control();

Rather than aliasing this to a private variable, the pattern shown here makes heavy use of .call() and .bind() to retain the context object. Note that any variables defined in the prototype scope are shared with all instances, so aliasing here is not permitted.

Limited privacy

All instances share one prototype definition with hidden methods, invoked automatically at startup.

While prototype methods can be hidden, they cannot access instance variables that are hidden in the constructor function. Therefore, client parameters (and timeout id) remain exposed.