Hi everyone,
I am reading Javascript the good parts and came across this that I
don't understand:
I haven't read it yet, but given what other stuff I've seen of
Crockford's he's fairly concise and assumes a reasonable level of
javascript knowledge.
Function.prototype.method = function ( name, func ) {
this.prototype[name] = func;
return this;
};
Number.method('integer' , function() {
return Math[this < 0 ? 'ceiling' : 'floor'](this);
});
My question is: what the hell is Function.prototype.method doing?
The code creates a property of Function.prototype called method. It
is assigned the function on the right hand side of the assignment
operator.
The function creates a property of the object referenced by its this
keyword with a name that is the value of the 'name' parameter and
assigns it a reference to whatever the value of func is (in this case,
it is expected to be a reference to a function). It returns the value
of its this keyword (I guess for convenience if it's required, it can
be ignored).
If I'd written the above, I'd probably have used the name 'addMethod'
rather than 'method'.
2nd What the hell is Number doing?
Number isn't "doing" anything. Number's internal [[prototype]]
property references Function.prototype, effectively making it an
instance of Function[1]. Because Function.prototype is on Number's
prototype chain, Number will "inherit" methods added to it (as will
all instances of Function). So adding method to Function.prototype
means that it will be available to Number as Number.method (and to
Array as Array.method and so on).
To be clear, when calling Number.method, the identifier 'method' will
be checked to see if it is a property of Number. If not found,
Number's internal [[prototype]] property will be checked - it
references Function.prototype, which has the newly added 'method' as a
property, so method is called with the value of its this keyword set
as a reference to Number.
Why do we have to go Function.prototype.method instead of just
Function.method? What does the prototype serve here?
Methods added to Number.prototype are "inherited" by instances of
Number. Methods added to Number belong to Number only, they aren't
inherited by other objects. Given that all constructors (and most
built-in objects are constructors) are instances of Function, I guess
Crockford wants all such objects to inherit the method function.
The method function added to Function.prototype provides a convenient
way of adding methods to any native constructor's prototype (including
both built-in and user-defined ones) and is effectively equivalent to
using <constructor>.prototype. The methods added with method will be
inherited by instances created by the constructors.
e.g.
function func(){}
var functionRef = func;
function Foo(){}
Foo.method('methodName0', functionRef);
Foo.method('methodName1', function() {/*...*/});
var foo = new Foo();
alert(typeof foo.methodName0) // -> function
alert(typeof foo.methodName1) // -> function
1. Quite a few of the built-in objects in javascript are set up this
way, such as Object, Array, String and others.
