Using timers within OO Javascript

Hey all, I'm having some trouble with window.setInterval() within a
custom object/prototype. Here is my code:

I'm stumped on this one; how do I set another method in the object as
the callback?

re: Using timers within OO Javascript

Evan Charlton wrote:Why are people so obsessed with classes when it comes to OOP? From the
above I thought you had understood that ECMAScript 3 implementations use
only prototype-based inheritance.
Why should there? It is merely a not evaluated read access to the
non-existing property `m_two' *of the Global Object*.
This is trying to call a method of the Global Object. Since the
identifier cannot be resolved, you get the runtime error.
This is trying to call an identifier without an explicit object
reference. Since the identifier cannot be resolved through the scope
chain, you get the runtime error.
This is trying to access an identifier without an explicit object
reference. Since the identifier cannot be resolved through the scope
chain, you get the runtime error.

As you can see, you cannot use a locally defined name in a string for
the window.setInterval() method (it would be the same with
window.setTimeout()). However, you can pass a Function object
reference, that is a reference to your method:

window.setInterval(this.m_two, 500);
Because timer() is a globally declared function, and (so) a method of
the Global Object. "this.timer()" should work as well.

}
HTH

PointedEars
--
var bugRiddenCrashPronePieceOfJunk = (
navigator.userAgent.indexOf('MSIE 5') != -1
&& navigator.userAgent.indexOf('Mac') != -1
) // Plone, register_function.js:16

re: Using timers within OO Javascript

Thomas 'PointedEars' Lahn wrote:Correction, use this instead to retain the method-object relationship:

window.setInterval(function callTwo() { this.m_two(); }, 500);


PointedEars
--
var bugRiddenCrashPronePieceOfJunk = (
navigator.userAgent.indexOf('MSIE 5') != -1
&& navigator.userAgent.indexOf('Mac') != -1
) // Plone, register_function.js:16

re: Using timers within OO Javascript

Thomas 'PointedEars' Lahn wrote:That is not going to help because when setInterval executes the function
expression (or the object resulting from the evaluation of the function
expression, to be precise) the - this - reference inside that function
will be to the global object and so - this.m_two - will have the same
meaning as when it was in the string in the earlier examples.

Richard.

re: Using timers within OO Javascript

This function may help you. It is from the Prototype javascript
library. (http://prototypejs.org/api)

Function.prototype.bind = function() {
var __method = this, args = arguments ? arguments : [], object =
args.shift();
return function() {
return __method.apply(object, args.concat(arguments ? arguments :
[]));
}
}

After placing this before the code below you can do this and it should
work:

instead of : window.setInterval( "this.m_two", 500 );
use: window.setInterval( this.m_two.bind ( this ), 500 );

What bind does is copies all of the methods and properties of 'this'
object into the m_two function as a new object. I've modified it a
bit, so if this doesn't work, just add the complete prototype library
from the site listed above.

re: Using timers within OO Javascript

Alternatively, if you don't need to access any of the class's
properties in "m_two", just do what Thomas said above:

re: Using timers within OO Javascript

Richard Cornford wrote:True, a closure is required:

this.m_one = function()
{
var me = this;
window.setInterval(function() { me.m_two(); }, 500);
};

this.m_two = function()
{
window.alert(this.m_one);
};


PointedEars
--
Prototype.js was written by people who don't know javascript for people
who don't know javascript. People who don't know javascript are not the
best source of advice on designing systems that use javascript.
-- Richard Cornford, <f806at$ail$1$8300dec7@news.demon.co.uk>

re: Using timers within OO Javascript

Thomas 'PointedEars' Lahn schrieb:You're wrong!

You definitely need closures for this, if you need access to this object:

function MyClass() {
//..
this.m_one = function() {
var me = this; // create a closure
this.interval = window.setInterval( function(){
me.m_two();
}, 1000 );
}
//..
}

br | rb
--
Sie freuten sich riesig, wenn eine Maschine nach sechs Stunden etwas
fertig brachte, wozu jeder Mensch auf der Straße für 2 Cent fähig
gewesen wäre. Anschließend ließen sie sich Bananen- und Sushi-Pizza
kommen und schliefen vor der Tastatur ein. [aus T.P., Heiße Hüpfer]

re: Using timers within OO Javascript

jamie.ly@gmail.com wrote:*sigh* *There* *is* *no* *class*. My sig happens to be proved by your
statement.


PointedEars
--
Prototype.js was written by people who don't know javascript for people
who don't know javascript. People who don't know javascript are not the
best source of advice on designing systems that use javascript.
-- Richard Cornford, <f806at$ail$1$8300dec7@news.demon.co.uk>

re: Using timers within OO Javascript

jamie.ly@gmail.com wrote:You have got to be joking. That is far too bad even for Prototype.js
code. I know that they have long since broken compatibility with ECMA
262 3rd Ed. but that is not even going to work in common browser
environments.

And what do they think - args = arguments ? arguments : [] - is about?
The existence of an - arguments - object, and that the Identifier
'arguments' will refer to that object, is absolutely guaranteed (short
of jumping through some extreme hoops with things like -
with({arguments:null}){ args = arguments?arguments:[];} -). And even
if - arguemtns - were allowed not exist the code would likely error out
at the first reference to it whenever it didn't. It would be difficult
to make this stuff up if you tried.
No it does not, and if it did that would be a disaster in this context
(and very many others) as the copy would be a copy of the state of the
object at the time of the setInterval call and so the method would end
up acting on an object with a (potentially) out-of-date state, and if it
needed to change the state of its object it would not be able to, but
instead would only change the state of the copy.
So what precisely did you modify? That is, how broken was it before you
started playing with it?
If? When it doesn't work! Opera may be the only browser where this does
work, and that is because of an ECMAScript bug in Opera.
Considering how utterly trivial the solution(s) to this problem is(are)
if you understand what you are doing, that has got to be one of the
worst suggestions possible.

Richard.

re: Using timers within OO Javascript

Thomas 'PointedEars' Lahn wrote:A closure is (or probably is) required, but only one.
As you have it every call to - m_one - will create a new function object
and a new closure. But if the closure was formed in the constructor (or
by other means (e.g. in an external function), but once only) with the -
m_two - method then the result would be more efficient.

function AnObject(){
var self = this;
this.m_two = function(){
// have this function refer to its object instance through the
// scope chain instead of through the - this - keyword and
// you only need one instance of this function
alert(self.m_one);
};
}

// and - m_one - does not need to created in the constructor
AnObject.prototoype.m_one = function(){
setInterval(this.m_two, 500);
};

And if the idea of creating the closure at the time of instantiation the
object did not appeal the 'Russian Doll' pattern (or similar) could be
applied to create it once, but at the first call to - m_one -.

function AnObject(){
}

AnObject.prototoype.m_two = function(){
alert(this.m_one);
};

AnObject.prototoype.m_one = function(){
var self = this;
function atIntervals(){
self.m_two();
}
(this.m_one = function(){
// This is the function that calls to - obj.m() - once use
directly
// following its indirect use in the first call.
setInterval(atIntervals, 500);
})();
};
One of my gripes about Prototype.js is the way in which it encourages
(even forces) horrendously inefficient use of functions, and especially
functions that are 'bound' to objects. You will often see Prototype.js
code where in real javascript you cold define/use a single instance of a
function and re-use it to your hart's content being implemented so that
a new function object is created on each and every use, or worse, a new
function created and then another with its own closure as the first is
'bound' to some object, but the same object on each occasion.

Richard.