Question

If I were to make a new function using the Function constructor, how could I give it a non-temporary scope to access besides window (meaning the scope only has to be evaluated once, not every time the function is called)? The purpose is to construct multiple variables that require some pretty costly calculations, and I don’t want to reconstruct them every time the function is called, but I also don’t want to store them in window. Any ideas?

Answer 1

For the above described purpose, you use static functions. You cannot prevent scope from being evaluated at every call, because this is the way JavaScript works, but you can speed it up by not having window in the scoping chain.

var namespace = {};
namespace.someMethod = function() {
    // do something here.
};

Now anywhere in your code, you can call that method by using namespace.someMethod();. Just be careful. The above is a static method. You can call it without instantiating. But you MUST NOT use this.property inside a static function. It is a potentially very dangerous operation, as it may give an extension access to the global object and basically un-restricted permissions.

And the above is a static JavaScript method. It does not have window in the scoping chain.

Here’s how to create a constructor using the same pattern. When you want to use a constructor, you always instantiate before using. For that you have the new keyword.

var namespace = {};
namespace.coordinate = function(x, y) {
    this.x = x;
    this.y = y;
};

namespace.coordinate.prototype.addCoordinates = function() {
    return this.x + this.y;


};

Now anywhere in your code you can do:

var coordinateObject = new namespace.coordinate(5,10);
// you have created a new instance.
alert(coordinateObject.addCoordinates());// will alert 15;
// now you can make as many as you want. They will behave as instances. 
// This means they do not interfere with each other in any way.
// They just have the same properties and methods, but the instance values
// Can be entirely different.

var secondCoordinateObject = new namespace.coordinate(10, 25);
alert(secondCoordinateObject.addCoordinates());// will output 35.

You have successufully created an instance of your namespace.coordinate class. Using the pattern I gave you, you can replicate almost the entire functionality of Java or C or any other Object Oriented language.