Species of Functions

Caja distinguishes different kinds of functions since different functions can do different things.

Constructors are used to create new objects, and act as both class and factory. Constructors can chain to their superclass, and manipulate the created object's protected interface via this. Any named function that mentions this is a constructor.

function ClassName(a, b) {
  BaseClass.call(this, a);
  this.b_ = b;  // define a protected field
}

Methods are functions attached to a particular class that can manipulate the protected interface of instances of that class via this. Any unnamed function that mentions this is a method.

caja.def(ClassName, SuperClass, {
  setB: function (b) { this.b_ = b; },
  getB: function () { return this.b_; }
});

Simple-functions don't have access to any object's protected interface, but can do anything else. Any function that doesn't mention this is a simple-function.

function foo(x, y) { return x + y; }

Exophoric Functions are created by calling caja.xo4a on a simple-function. When an exophoric function is called as a method, the object the method is called on will bound to the simple-function's first parameter, and the actual arguments are bound to the remaining parameters. To emphasize the this-like nature of this first parameter variable, its conventional name is self.

node.addListener('click', caja.xo4a(function(self) { handleClickEvent(self.id); }));

acts like

node.addListener('click', function() { handleClickEvent(this.id); });

does in uncajoled JavaScript. The first form will work both cajoled and uncajoled. As a temporary hack (when warts mode flag is on), the second form will currently work cajoled as well, but will shortly need to be rewritten as the first form.

Calling Functions

A function can be declared any of the ways above, but calling is more flexible.

. . . Functions defined as can be . . .