By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
459,377 Members | 1,655 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 459,377 IT Pros & Developers. It's quick & easy.

Augmenting functions

P: n/a
Hi everyone,
I am reading Javascript the good parts and came across this that I
don't understand:

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?
2nd What the hell is Number doing?

Why do we have to go Function.prototype.method instead of just
Function.method? What does the prototype serve here?
Nov 13 '08 #1
Share this Question
Share on Google+
6 Replies


P: n/a
On Nov 13, 12:28*pm, disappearedng <disappeare...@gmail.comwrote:
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.
--
Rob
Nov 13 '08 #2

P: n/a
On Nov 13, 1:30*pm, RobG <rg...@iinet.net.auwrote:
On Nov 13, 12:28*pm, disappearedng <disappeare...@gmail.comwrote:
[...]
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.
Number in my reply above should of course have been Function, i.e.
methods added to Function.prototype are inherited by instances of
Function, which includes constructors.

As a further note, had method been added to Function, to have the same
effect it would have to have been called as:

Function.method.call(constructor, name, func);

e.g. from the Number example:

Function.method.call(Number, 'integer' , function() {...});
rather than:

constructor.method(name, func);

--
Rob
Nov 13 '08 #3

P: n/a
On Nov 13, 3:28*am, disappearedng <disappeare...@gmail.comwrote:
Function.prototype.method = function( name, func ) {
this.prototype[ name ] = func;
return this;
};
Number.method( 'integer', function() {
return Math[ this < 0 ? 'ceil' : 'floor' ]( this );
} );
What the hell is Number doing?
The above code assigns a new method named 'integer' to all Number
objects.
You can test it as follows:

var x = 3.5;
alert( x.integer() ); // 3

var y = -4.5;
alert( y.integer() ); // -4

Hubert

PS: Note that 'ceil' is the correct name, not 'ceiling'.
Nov 13 '08 #4

P: n/a
On Wed, 12 Nov 2008 at 18:28:42, in comp.lang.javascript, disappearedng
wrote:
>Hi everyone,
I am reading Javascript the good parts and came across this that I
don't understand:
<snip>

I hope you've understood that Crockford is creating the language he
would have invented if he'd had the chance. It's not always easy to work
out why he's doing it.

John
--
John Harris
Nov 14 '08 #5

P: n/a
On Nov 13, 11:42*am, John G Harris <j...@nospam.demon.co.ukwrote:
On Wed, 12 Nov 2008 at 18:28:42, in comp.lang.javascript, disappearedng
wrote:>Hi everyone,
I am reading Javascript the good parts and came across this that I
don't understand:

* <snip>

I hope you've understood that Crockford is creating the language he
would have invented if he'd had the chance. It's not always easy to work
out why he's doing it.
I wonder why it is called 'method', when it could be called
'setPrototypeProperty'. Because that's exactly what this:

Function.prototype.method = function ( name, func ) {
this.prototype[name] = func;
return this;
};

- does. It's clearer to just use:-

Inline code would be an alternative:-

n |= 0; // chop off decimal.

No conversion to object, no function call and doesn't change
Number.prototype.

Garrett
* John
--
John Harris
Nov 14 '08 #6

P: n/a
On Thu, 13 Nov 2008 at 17:45:01, in comp.lang.javascript, dhtml wrote:
>On Nov 13, 11:42*am, John G Harris <j...@nospam.demon.co.ukwrote:
>On Wed, 12 Nov 2008 at 18:28:42, in comp.lang.javascript, disappearedng
wrote:>Hi everyone,
>I am reading Javascript the good parts and came across this that I
don't understand:

* <snip>

I hope you've understood that Crockford is creating the language he
would have invented if he'd had the chance. It's not always easy to work
out why he's doing it.

I wonder why it is called 'method', when it could be called
'setPrototypeProperty'.
<snip>

Because he's not a good designer ?

He sometimes forgets to type 'new' and the compiler doesn't notice, so
you mustn't use 'new'.

You might forget to type 'else' and the compiler won't notice, but
that's all right because he doesn't make that mistake.

Yea verily, he's not the thinking programmer's greatest framework
designer.

John
--
John Harris
Nov 14 '08 #7

This discussion thread is closed

Replies have been disabled for this discussion.