GET requests to change data server-side, use POST (for example, when using Ajax to modify things server-side). GETs are supposed to be idempotent, which is a fancy way of saying that doing them repeatedly has the same effect as doing them once. So, GET the contents of a message on a message board, but POST new messages to the board.WEB-INF directory and its subdirectories, which I kind of don't want Apache to serve up to the public! If you use .htaccess files, you'll have the same sort of situation.<Files ~ "^\.ht">
Order allow,deny
Deny from all
</Files>.htaccess. And the same sort of thing can be applied for WEB-INF using the DirectoryMatch directive:<DirectoryMatch "(^|/)WEB-INF($|/)">
Deny from all
</DirectoryMatch>mod_rewrite to the rescue!<DirectoryMatch "(^|/)WEB-INF($|/)">
RewriteEngine on
RewriteRule .* - [L,R=404]
</DirectoryMatch>RewriteRule is already inside the DirectoryMatch that will only match what we want, its own regex can just match everything. The L flag says this is the last rule, but the R flag is the magic: It forces a redirect, and if you use the R=xyz form, it redirects with the given code; in this case, a 404. This does the right thing even if you have a custom error document (and you have custom error documents, right?).WEB-INF directory there at all.mod_rewrite is loaded or not:<DirectoryMatch "(^|/)WEB-INF($|/)">
<IfModule mod_rewrite.c>
RewriteEngine on
RewriteRule .* - [L,R=404]
</IfModule>
<IfModule !mod_rewrite.c>
Deny from all
</IfModule>
</DirectoryMatch>mod_rewrite is loaded, but fall back to a 403 of not.WEB-INF diretory (or whatever you're hiding) in those listings. It's easy enough to do it, though: Inside the relevant directive for the directory being listed, just use IndexIgnore to tell the mod_autoindex module to ignore it:IndexIgnore WEB-INFWEB-INF to be hidden everywhere, I can just include it inside my main Directory directive. I never let Apache generate listings for me anyway, but it's nice to have a backstop if I blow away my index file.
var CoolModule = (function() {
function foo() { ... }
function bar() { ... }
function cool() { ... }
return {foo: foo, bar: bar};
})();CoolModule variable. We end up with a CoolModule object with the properties foo and bar that refer to named functions with the same names. Note that in this example, I did not include cool in the returned object's properties. So what's cool for?cool function is accessible anywhere within the scoping function, but nowhere outside of it. So foo can use it, as can bar, but nothing else can. It's a truly private function for the CoolModule module. That's already really useful, but we can also apply it to classes:Class.create, we can define a class like so:var Thingy = Class.create({
initialize: function(name) {
this.name = name;
},
doSomething: function() {
// ...
}
});Class.create uses to produce a "class" for us (well, more technically a constructor function with the given methods as members on the prototype; JavaScript doesn't have classes, of course, it's a prototypical language — but that's a different subject).Thingy that way has a problem: All of its functions are anonymous. They're assigned to properties, and those properties have names, but our functions do not. This is a problem any time any tool wants to help us out &mdash for instance, if the browser wants to tell us what function an error occurred in, or if a debugger wants to show us the call stack. So we're better off using the module pattern here, like so:var Thingy = Class.create((function(){
function initialize(name) {
this.name = name;
}
function doSomething() {
// ...
}
return {initialize: initialize, doSomething: doSomething};
})());cool function from earlier, the one we defined but didn't export. The easiest and most obvious benefit we get from our scoping function is that we immediately have class methods with no need for any other work: We just define a function and don't export it in the return value. It's available to all of our other functions, but it's completely closed off from the outside. It's not tied to any instance, but class methods are quite useful things.var Thingy = Class.create((function(){
function initialize(name) {
this.name = name;
}
function doSomething(param) {
var transmogrified = transmogrify(param);
// ...
}
function transmogrify(str) {
return str.toUpperCase();
}
return {initialize: initialize, doSomething: doSomething};
})());doSomething uses our private class method transmogrify to do something to its parameter, presumably something other methods will also need to do but which shouldn't be a public feature of the class. Very handy!this" value). JavaScript provides three ways to do that:obj.method()Function#callFunction#applyFunction#call or Function#apply. Here's an example:var Thingy = Class.create((function(){
function initialize(name) {
this.name = name;
}
function doPublic() {
doPrivate.call(this);
}
function doPrivate() {
alert(this.name);
}
return {
initialize: initialize,
doPublic: doPublic
};
})());
var t = new Thing("Fred");
t.doPublic(); // Alerts "Fred" via private instance methoddoPublic function calls our doPrivate function via Function#call; our truly private instance method then shows the name of the Thingy. doPrivate's context ("this") is set to the instance, and so it has normal access to the instance's properties, including name. Voilà! (Sort of.)doPrivate.call(this)" looked vaguely familiar, we may have something in common: A background in procedural languages. Using Function#call to call a function and set its context looks very much like just calling a function and passing it a parameter. So even though it's cheating a bit, let's just give a nod to procedural programming here:var Thingy = Class.create((function(){
function initialize(name) {
this.name = name;
}
function doPublic() {
doPrivate(this);
}
function doPrivate(self) {
alert(self.name);
}
return {
initialize: initialize,
doPublic: doPublic
};
})());
var t = new Thing("Fred");
t.doPublic(); // Alerts "Fred"doPublic call doPrivate in a procedural fashion, passing in the "this" reference. Since there are no private properties in JavaScript, doPrivate has access to just as much information as it did when called in a more instance-like way.this.method()this" as its prototype? Then we can put the private methods on it, and no one else can see them. Well, this does work, but the costs are pretty high. Let's walk through it.this" as its prototype? Well that part's actually quite easy: We just have a constructor function lying around, set its prototype property to the instance we want to be the prototype, create a new instance with it, and then restore the constructor's prototype (just to be tidy, we shouldn't keep a reference to the other instance anywhere). (Some browsers let us directly manipulate the prototype of an actual object via a __proto__ property, but others don't and it hasn't been standardized, so we'll stick to the constructor way.) Here's what that looks like:var Helper = (function() {
// A factory for setting up our private instances
function factory() {
}
// Our public makePrivate function
function makePrivate(instance, privateMethods) {
var rv, name;
// Set the prototype of our factory
factory.prototype = instance;
// Get our private instance
rv = new factory();
// Reset the factory prototype (just to be tidy)
factory.prototype = Object.prototype;
// Copy over the private methods
for (name in privateMethods) {
rv[name] = privateMethods[name];
}
// Done
return rv;
}
// Publish the "makePrivate" function
return {makePrivate: makePrivate};
})();var Thingy = Class.create((function() {
var privateMethods;
// The private methods for our class
privateMethods = {
doPrivate: doPrivate
};
function initialize(name) {
this.name = name;
}
function doPublic() {
var self;
// Get a version of "this" that has our private stuff
self = Helper.makePrivate(this, privateMethods);
// Use it
self.doPrivate();
}
function doPrivate() {
alert(this.name);
}
return {
initialize: initialize,
doPublic: doPublic
};
})());
var t = new Thingy("Fred");
t.doPublic(); // Alerts "Fred"doPublic), any changes are lost with it &mdash e.g., if doPrivate changes anything: function doPrivate() {
alert(this.name);
this.name = this.name.toUpperCase();
}var t = new Thing("Fred");
t.doPublic(); // Alerts "Fred"
alert(t.name); // Also alerts "Fred", not "FRED"this will refer to our private instance). Worse, not only your own methods, but all superclass methods also have to use it. Now, if you're an adherent to the philosophy that all property access should be through getters and setters anyway, that will work, and your setter would look like this:function setName(name) {
var inst = this.hasOwnProperty('_original')
? this._original
: this;
inst.name = name;
}makePrivate to store the original instance on the private instance as the property _original. If you're not an adherent of that getter/setter philosophy, though (and I've never seen any substantial JavaScript written by anyone who was), it's a problem.var Helper = (function() {
// A factory for setting up our private instances
function factory() {
}
// Our public enterPrivate function
function enterPrivate(instance, methods) {
var rv, name;
// Set the prototype of our factory
factory.prototype = instance;
// Get our private instance
rv = new factory();
// Restore the factory prototype (just to be tidy)
factory.prototype = Object.prototype;
// Remember the private methods and the original
// object, we'll want them for later
rv._privateMethods = methods;
rv._original = instance;
// Copy over the private methods
for (name in methods) {
rv[name] = methods[name];
}
// Done
return rv;
}
// Our public exitPrivate function
function exitPrivate(instance) {
var name, original;
original = instance._original;
for (name in instance) {
if (name != '_original' &&
instance.hasOwnProperty(name) &&
!(name in instance._privateMethods)
) {
original[name] = instance[name];
}
}
return original;
}
// Export our public functions
return {enterPrivate: enterPrivate, exitPrivate: exitPrivate};
})();var Thingy = Class.create((function() {
var privateMethods;
// The private methods for our class
privateMethods = {
doPrivate: doPrivate
};
function initialize(name) {
this.name = name;
}
function doPrivate() {
alert(this.name);
this.name = this.name.toUpperCase();
}
function doPublic(name) {
var self;
// Public->Private boundary, need to "enter" private mode
self = Helper.enterPrivate(this, privateMethods);
// ...do things...
self.doPrivate();
// Private->Public boundary, need to "exit" private mode
Helper.exitPrivate(self);
}
return {
initialize: initialize,
doPublic: doPublic
};
})());
var t = new Thing("Fred");
t.doPublic(); // Alerts "Fred"
alert(t.name); // Also alerts "FRED"exitPrivate!).enterPrivate and exitPrivate functions mean we incur a lot of runtime overhead; but at least once we're "in," we're able to do things with completely normal syntax and it Just Works. And using prototypes in this way is very cool. Unfortunately, though, all of that copying back and forth and object instantiation really does kill performance.var Helper = (function() {
// Our public enterPrivate function
function enterPrivate(instance, methods) {
var old, name;
old = {};
for (name in methods) {
if (instance.hasOwnProperty(name)) {
old[name] = instance[name];
}
instance[name] = methods[name];
}
if (instance.hasOwnProperty('_oldStuff') && !('_oldStuff' in old)) {
old._oldStuff = instance._oldStuff;
}
if (instance.hasOwnProperty('_methods') && !('_methods' in old)) {
old._methods = instance._methods;
}
instance._methods = methods;
instance._oldStuff = old;
return instance;
}
// Our public exitPrivate function
function exitPrivate(instance) {
var methods, old, name;
methods = instance._methods;
delete instance._methods;
old = instance._oldStuff;
delete instance._oldStuff;
for (name in methods) {
delete instance[name];
}
for (name in old) {
instance[name] = old[name];
}
return instance;
}
// Export our public functions
return {enterPrivate: enterPrivate, exitPrivate: exitPrivate};
})();var Thingy = Class.create((function() {
var privateMethods;
// Our private methods
privateMethods = {
doPrivate: doPrivate1
};
function initialize(name) {
this.name = name;
}
function doPrivate() {
alert(this.name);
this.name = this.name.toUpperCase();
}
function doPublic(name) {
// Public->Private boundary, need to "enter" private mode
Helper.enterPrivate(this, privateMethods);
// Do some stuff
this.doPrivate();
// Private->Public boundary, need to "exit" private mode
Helper.exitPrivate(this);
}
return {
initialize: initialize,
doPublic: doPublic
};
})());
var t = new Thingy();
t.doPublic(); // Alerts "Fred"
alert(t.name); // Alerts "FRED"Function#call variety.
Function#call instead isn't very high, if you really prefer that).In this post, I'll be outlining a simple means of doing supercalls in JavaScript without causing unnecessary runtime overhead, running into maintenance issues, or falling afoul of the new "strict" mode of ECMAScript 5.
Function#call or Function#apply on the $super property of the subclass function instance (being sure to get the function directly, not via this). This is simplest and fastest with named functions, but possible with anonymous ones too.Class over and reading through the code, and realized that what Prototype does under the covers to make supercalls work (which includes function decompilation, wrapping in closures, and creating a new function on every call to a supercall-enabled method) is an awful lot of runtime overhead.// Defining the class
var SpiffyClass = Helper.makeClass({
initialize: function() {
// ...initialize an instance...
},
nifty: function() {
// ...do something nifty...
}
});
// Creating an instance
var spiffy = new SpiffyClass();Helper.makeClass might look like — the code comments basically tell the story (download it here if the below is awkward to read; I hate Blogger!):// Take I, doesn't help with supercalls.
// Inspired by Prototype's Class class (http://prototypejs.org)
// Copyright (C) 2009-2010 by T.J. Crowder
// Licensed under the Creative Commons Attribution License 2.0 (UK)
// http://creativecommons.org/licenses/by/2.0/uk/
var Helper = (function(){
// This function is used to create the prototype object for our generated
// constructors if the class has a parent class. See makeConstructor for details.
function protoCtor() { }
// Build and return a constructor; we do this with a separate function
// to minimize what the new constructor (a closure) closes over.
function makeConstructor(base) {
// Here's our basic constructor function (each class gets its own, a
// new one of these is created every time makeConstructor is called).
function ctor() {
// Call the initialize method
this.initialize.apply(this, arguments);
}
// If there's a base class, hook it up. We go indirectly through `protoCtor`
// rather than simply doing "new base()" because calling `base` will call the base
// class's `initialize` function, which we don't want to execute. We just want the
// prototype.
if (base) {
protoCtor.prototype = base.prototype;
ctor.prototype = new protoCtor();
protoCtor.prototype = {}; // Don't leave a dangling reference
}
// Set the prototype's constructor property so `this.constructor` resolves
// correctly
ctor.prototype.constructor = ctor;
// Return the newly-constructed constructor
return ctor;
}
// This function is used when a class doesn't have its own initialize
// function; since it does nothing and can only appear on base classes,
// all instances can share it.
function defaultInitialize() {
}
// makeClass: Our public "make a class" function.
// Arguments:
// - base: An optional constructor for the base class.
// - ...: One or more specification objects containing properties to
// put on our class as members. If a property is defined by more
// than one specification object, the last in the list wins.
// Returns:
// A constructor function for instances of the class.
//
// Typical use will be just one specification object, but allow for more
// in case the author is drawing members from multiple locations.
function makeClass() {
var base, // Our base class (constructor function), if any
argsIndex, // Index of first unused argument in 'arguments'
ctor, // The constructor function we create and return
members, // Each members specification object
name; // Each name in 'members'
// We use this index to keep track of the arguments we've consumed
argsIndex = 0;
// Do we have a base?
if (typeof arguments[argsIndex] == 'function') {
// Yes
base = arguments[argsIndex++];
}
// Get our constructor; this will hook up the base class's prototype
// if there's a base class
ctor = makeConstructor(base);
// Assign the members from the specification object(s) to the prototype
// Again, typically there's only spec object, but allow for more
while (argsIndex < arguments.length) {
// Get this specification object
members = arguments[argsIndex++];
// Copy its members
for (name in members) {
ctor.prototype[name] = members[name];
}
}
// If there's no initialize function, provide one
if (!('initialize' in ctor.prototype)) {
// Note that this can only happen in base classes; in a derived
// class, the check above will find the base class's version if the
// subclass didn't define one.
ctor.prototype.initialize = defaultInitialize;
}
// Return the constructor
return ctor;
}
// Return our public members
return {makeClass: makeClass};
})();var Parent = Helper.makeClass({
nifty: function() {
return "Nifty!";
}
});
var Child = Helper.makeClass(Parent, {
spiffy: function() {
return "Spiffy!";
}
});
var c = new Child();
alert(c.nifty()); // Alerts "Nifty!" using Parent#nifty
alert(c.spiffy()); // Alerts "Spiffy!" using Child#spiffy#nifty in Child to do some processing on Parent's return value? Well, we can do that by going direct to the parent and using Function#call (or Function#apply), but the syntax is quite awkward:var Child = Helper.makeClass(Parent, {
nifty: function() {
var rv = Parent.prototype.nifty.call(this);
return rv.toUpperCase();
},
spiffy: function() {
return "Spiffy!";
}
});
var c = new Child();
alert(c.nifty()); // Alerts "NIFTY!"makeClass function has all of the information it needs to help us out: It can easily tell when we're overriding a base class function, and it can give us a reference to that function without our having to know the base class name. How? By putting it on our function instance. Remember that functions are first-class objects, we can put properties on them.makeClass, when copying the members from the specification object(s) to the new constructor's prototype, if a member we're copying is a function and we have a base and the base value is also a function, we stick it on the override function as $super. E.g., we replace these lines from earlier:for (name in members) {
ctor.prototype[name] = members[name];
}for (name in members) {
value = members[name];
if (base && typeof value == 'function') {
baseValue = base.prototype[name];
if (typeof baseValue == 'function') {
value.$super = baseValue;
}
}
ctor.prototype[name] = value;
}$super property on our own function. But how do we get that? In our Child#nifty function earlier, say, how do we get to Parent#nifty? If your first thought (like mine) is this.nifty.$super, I'm afraid you're not thinking it through — that will work only for one level of hierarchy, it will fail if anything (say, GrandChild) derives from Child and has its own #nifty function, because with a GrandChild instance, this.nifty is always GrandChild#nifty. If Child#nifty called this.nifty.$super in that situation, it would be calling itself, not Parent#nifty, recursing until the engine gave up on it. So this is out.this, and that means it'll always point to the bottommost — GrandChild — function). So now what?arguments.callee. The arguments object, I'm sure you know, is an array-like object defined within functions that contains the arguments passed into the function. That object also has a property on it called callee that is a reference to the actual function object. So we can get at our super function using arguments.callee.$super. And like all other functions, we can call it and pass in the value to use as this by using the Function#call function. So:var Child = Helper.makeClass(Parent, {
nifty: function() {
var rv = arguments.callee.$super.call(this); // Blech
return rv.toUpperCase();
},
});
alert(c.nifty()); // Alerts "NIFTY!"arguments.callee (amongst other things) is disallowed (many thanks to John-David Dalton and Juriy Zaytsev — kangax — for pointing this out to me)arguments.callee unless you use it, and they're pretty slow at setting it up (thanks again, kangax, for that one)var Child = Helper.makeClass(Parent, {
nifty: function nifty() { // <= PROBLEMATIC
// ...
}
});nifty" gets defined in the enclosing scope, which in our case above is global — not a good idea! And it flat out doesn't work with Internet Explorer (or anywhere you're using JScript) or Safari. (For the full story, check out Juriy's excellent article on the subject, it's a good read.)var Child = Helper.makeClass(Parent, (function(){
function nifty() {
// ...
}
function spiffy() {
// ...
}
return {
nifty: nifty,
spiffy: spiffy
};
})());Child — as named functionsmakeClassChild#nifty! Here we go:var Child = Helper.makeClass(Parent, (function(){
function nifty() {
var rv = nifty.$super.call(this);
return rv.toUpperCase();
}
function spiffy() {
// ...
}
return {
nifty: nifty,
spiffy: spiffy
};
})());
var c = new Child();
alert(c.nifty()); // Alerts "NIFTY!"#nifty, we refer to the function by name — no this, that's very important! — which always refers to the right one. We get its $super property, and use Function#call on it. (We could use Function#apply if we wanted.) We pass in this as the context parameter so that this is correct within the supercall.makeClass should just support our passing those functions in directly rather than making us execute them first. It simplifies the syntax markedly:var Child = Helper.makeClass(Parent, function(){
function nifty() {
var rv = nifty.$super.call(this);
return rv.toUpperCase();
}
return {nifty: nifty};
});
var c = new Child();
alert(c.nifty()); // Alerts "NIFTY!"makeClass will call it for us. So let's go support that in makeClass (we'll still support providing the specification object directly) by marking constructor functions (so we know whether we have a base class, since everything might be a function now — this was also Allen's idea) and then just invoking any functions we find to get their specification objects. (Code below under "Bringing It All Together".)Helper.makeClass allows multiple specification objects. Suppose we have a mixin that provides semantics around getting and setting a "cool" property:var CoolMixin = (function(){
function setCool(cool) {
if (typeof cool != 'string') {
throw "Hey, man, that ain't cool.";
}
this.cool = cool;
}
function getCool() {
return this.cool;
}
return {getCool: getCool, setCool: setCool};
})();var CoolChild = Helper.makeClass(Parent, CoolMixin, function() {
function spiffy() {
// ...
}
return {spiffy: spiffy};
});
var cc = new CoolChild();
alert(cc.nifty()); // Alerts "Nifty!" via Parent#nifty
cc.setCool(1); // throws the uncool exceptionCoolChild inherits from Parent, but also gets the cool stuff from CoolMixin. By convention (and in order to ensure that a subclass's own members take precedence), mixins are always included after the parent and before the child's own members.makeClass: Normally, it modifies function instances, setting a $super property on them if they override a base class function (it leaves them alone if they don't). But mixins are used in multiple classes, so we shouldn't touch them. While in practice it would be fairly harmless to set $super on the mixin function if the mixin function didn't call $super (which is definitely an edge case), it's still not right and in certain very edgy edge cases could cause class cross-talk, which is a Bad Thing(tm).makeClass to leave them alone. (I actually mark the methods rather than doing it by context because some implementations — like Prototype — allow modifying hierarchies after initial derivation, in which case it's really important to know which functions are mixin functions and which aren't). It may seem to be pandering to an edge case, but there's effectively no runtime cost and the code is trivial, so let's do it — see Helper.makeMixin below.$super property on the wrapper. I haven't done that here, but it's a viable solution if you think mixins calling $super is a common enough use case for you.arguments.callee.$super.call(this, ...);this.callSuper(arguments, ...);CallSuperMixin below.Helper.makeMixin, we end up with this:// Take IV: Explicitly handle mixins, provide a mixin for calling super when
// working with anonymous functions.
// Inspired by Prototype's Class class (http://prototypejs.org)
// Copyright (C) 2009-2010 by T.J. Crowder
// Licensed under the Creative Commons Attribution License 2.0 (UK)
// http://creativecommons.org/licenses/by/2.0/uk/
var Helper = (function(){
var toStringProblematic, // true if 'toString' may be missing from for..in
valueOfProblematic; // true if 'valueOf' may be missing from for..in
// IE doesn't enumerate toString or valueOf; detect that (once) and
// remember so makeClass can deal with it. We do this with an anonymous
// function we don't keep a reference to to minimize what we keep
// around when we're done.
(function(){
var name;
toStringProblematic = valueOfProblematic = true;
for (name in {toString: true, valueOf: true}) {
if (name == 'toString') {
toStringProblematic = false;
}
if (name == 'valueOf') {
valueOfProblematic = false;
}
}
})();
// This function is used to create the prototype object for our generated
// constructors if the class has a parent class. See makeConstructor for details.
function protoCtor() { }
// Build and return a constructor; we do this with a separate function
// to minimize what the new constructor (a closure) closes over.
function makeConstructor(base) {
// Here's our basic constructor function (each class gets its own, a
// new one of these is created every time makeConstructor is called).
function ctor() {
// Call the initialize method
this.initialize.apply(this, arguments);
}
// If there's a base class, hook it up. We go indirectly through `protoCtor`
// rather than simply doing "new base()" because calling `base` will call the base
// class's `initialize` function, which we don't want to execute. We just want the
// prototype.
if (base) {
protoCtor.prototype = base.prototype;
ctor.prototype = new protoCtor();
protoCtor.prototype = {}; // Don't leave a dangling reference
}
// Set the prototype's constructor property so `this.constructor` resolves
// correctly
ctor.prototype.constructor = ctor;
// Flag up that this is a constructor (for mixin support)
ctor._isConstructor = true;
// Return the newly-constructed constructor
return ctor;
}
// This function is used when a class doesn't have its own initialize
// function; since it does nothing and can only appear on base classes,
// all instances can share it.
function defaultInitialize() {
}
// Get the names in a specification object, allowing for toString and
// valueOf issues
function getNames(members) {
var names, // The names of the properties in 'members'
name, // Each name
nameIndex; // Index into 'names'
names = [];
nameIndex = 0;
for (name in members) {
names[nameIndex++] = name;
}
if (toStringProblematic && typeof members.toString != 'undefined') {
names[nameIndex++] = 'toString';
}
if (valueOfProblematic && typeof members.valueOf != 'undefined') {
names[nameIndex++] = 'valueOf';
}
return names;
}
// makeClass: Our public "make a class" function.
// Arguments:
// - base: An optional constructor for the base class.
// - ...: One or more specification objects containing properties to
// put on our class as members; or functions that return
// specification objects. If a property is defined by more than one
// specification object, the last in the list wins.
// Returns:
// A constructor function for instances of the class.
//
// Typical use will be just one specification object, but allow for more
// in case the author is drawing members from multiple locations.
function makeClass() {
var base, // Our base class (constructor function), if any
argsIndex, // Index of first unused argument in 'arguments'
ctor, // The constructor function we create and return
members, // Each members specification object
names, // The names of the properties in 'members'
nameIndex, // Index into 'names'
name, // Each name in 'names'
value, // The value for each name
baseValue; // The base class's value for the name
// We use this index to keep track of the arguments we've consumed
argsIndex = 0;
// Do we have a base?
if (typeof arguments[argsIndex] == 'function' &&
arguments[argsIndex]._isConstructor) {
// Yes
base = arguments[argsIndex++];
}
// Get our constructor; this will hook up the base class's prototype
// if there's a base class, and mark the new constructor as a constructor
ctor = makeConstructor(base);
// Assign the members from the specification object(s) to the prototype
// Again, typically there's only spec object, but allow for more
while (argsIndex < arguments.length) {
// Get this specification object
members = arguments[argsIndex++];
if (typeof members == 'function') {
members = members();
}
// Get all of its names
names = getNames(members);
// Copy the members
for (nameIndex = names.length - 1; nameIndex >= 0; --nameIndex) {
name = names[nameIndex];
value = members[name];
if (base && typeof value == 'function' && !value._isMixinFunction) {
baseValue = base.prototype[name];
if (typeof baseValue == 'function') {
value.$super = baseValue;
}
}
ctor.prototype[name] = value;
}
}
// If there's no initialize function, provide one
if (!('initialize' in ctor.prototype)) {
// Note that this can only happen in base classes; in a derived
// class, the check above will find the base class's version if the
// subclass didn't define one.
ctor.prototype.initialize = defaultInitialize;
}
// Return the constructor
return ctor;
}
// makeMixin: Our public "make a mixin" function.
// Arguments:
// - ...: One or more specification objects containing properties to
// put on our class as members; or functions that return
// specification objects. If a property is defined by more than one
// specification object, the last in the list wins.
// Returns:
// A specification object containing all of the members, flagged as
// mixin members.
function makeMixin() {
var rv, // Our return value
argsIndex, // Index of first unused argument in 'arguments'
members, // Each members specification object
names, // The names in each 'members'
value; // Each value as we copy it
// Set up our return object
rv = {};
// Loop through the args (usually just one, but...)
argsIndex = 0;
while (argsIndex < arguments.length) {
// Get this members specification object
members = arguments[argsIndex++];
if (typeof members == 'function') {
members = members();
}
// Get its names
names = getNames(members);
// Copy its members, marking them as we go
for (nameIndex = names.length - 1; nameIndex >= 0; --nameIndex) {
name = names[nameIndex];
value = members[name];
if (typeof value == 'function') {
value._isMixinFunction = true;
}
rv[name] = value;
}
}
// Return the consolidated, marked specification object
return rv;
}
// Return our public members
return {
makeClass: makeClass,
makeMixin: makeMixin
};
})();var Parent = Helper.makeClass(function(){
function hierarchy() {
return "P";
}
return {hierarchy: hierarchy};
});
var Child = Helper.makeClass(Parent, function(){
function hierarchy() {
return hierarchy.$super.call(this) + " < C";
}
return {hierarchy: hierarchy};
});
var GrandChild = Helper.makeClass(Child, function(){
function hierarchy() {
return hierarchy.$super.call(this) + " < GC";
}
return {hierarchy: hierarchy};
});
var gc = new GrandChild();
alert(gc.hierarchy()); // Alerts "P < C < GC"// Define our CallSuper mixin
Helper.CallSuperMixin = makeMixin(function() {
function callSuper(ref) {
var f, // The function to call
args, // Arguments to pass it, if we have any
len, // Length of args to pass
srcIndex, // When copying, the index into 'arguments'
destIndex, // When copying args, the index into 'args'
rv; // Our return value
// Get the function to call: If they pass in a function, it's the
// subclass's version so look on $super; otherwise, they've passed
// in 'arguments' and it's on arguments.callee.$super.
f = typeof ref == 'function' ? ref.$super : ref.callee.$super;
// Only proceed if we have 'f'
if (f) {
// If there are no args to pass on, use Function#call
if (arguments.length == 1) {
rv = f.call(this);
} else {
// We have args to pass on, build them up.
// Note that doing this ourselves is more efficient on most
// implementations than applying Array.prototype.slice to
// 'arguments', even though it's built in; the call to it
// is expensive (dramatically, on some platforms).
len = arguments.length - 1;
args = new Array(len);
srcIndex = 1;
destIndex = 0;
while (destIndex < len) {
args[destIndex++] = arguments[srcIndex++];
}
// Use Function#apply
rv = f.apply(this, args);
}
}
// Done
return rv; // Will be undefined if there was no 'f' to call
}
return {callSuper: callSuper};
});Helper provided here. The goal is to demonstrate a really simple, highly efficient means of implementing supercalls in these sorts of libraries, and discussing some edge cases around doing so. If you use Prototype, you might want to take a look at my patch for Prototype 1.6.1 (I have no idea whether that will make it into Prototype), which handles dynamic redefinition and such (although that patch doesn't — yet — handle mixins).Child#nifty) is overriding a superclass function (Parent#nifty) and, if so, put a reference to the superclass function on the subclass function instance as a property.Function#call or Function#apply on the $super property of the subclass function instance (being sure to get the function directly, not via this). This is simplest and fastest with named functions, but possible with anonymous ones too.