Augmenting functions

[disappearedng]

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

Function.protot ype.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.protot ype.method doing?
2nd What the hell is Number doing?

Why do we have to go Function.protot ype.method instead of just
Function.method ? What does the prototype serve here?

[RobG]

Re: Augmenting functions

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.protot ype.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.protot ype.method doing?

The code creates a property of Function.protot ype 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.protot ype, effectively making it an
instance of Function[1]. Because Function.protot ype is on Number's
prototype chain, Number will "inherit" methods added to it (as will
all instances of Function). So adding method to Function.protot ype
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.protot ype, 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.protot ype.method instead of just
Function.method ? What does the prototype serve here?

Methods added to Number.prototyp e 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.protot ype 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>.p rototype. 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('met hodName0', functionRef);
Foo.method('met hodName1', 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

[RobG]

Re: Augmenting functions

On Nov 13, 1:30 pm, RobG <rg...@iinet.ne t.auwrote:

On Nov 13, 12:28 pm, disappearedng <disappeare...@ gmail.comwrote:

[...]

Why do we have to go Function.protot ype.method instead of just
Function.method ? What does the prototype serve here?

>
Methods added to Number.prototyp e 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.protot ype 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(construct or, name, func);

e.g. from the Number example:

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


rather than:

constructor.met hod(name, func);



--
Rob

[hubert.kauker@travelbasys.de]

Re: Augmenting functions

On Nov 13, 3:28 am, disappearedng <disappeare...@ gmail.comwrote:

Function.protot ype.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'.

[John G Harris]

Re: Augmenting functions

On Wed, 12 Nov 2008 at 18:28:42, in comp.lang.javas cript, 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

[dhtml]

Re: Augmenting functions

On Nov 13, 11:42 am, John G Harris <j...@nospam.de mon.co.ukwrote:

On Wed, 12 Nov 2008 at 18:28:42, in comp.lang.javas cript, 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
'setPrototypePr operty'. Because that's exactly what this:

Function.protot ype.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.prototyp e.

Garrett

  John
--
John Harris

[John G Harris]

Re: Augmenting functions

On Thu, 13 Nov 2008 at 17:45:01, in comp.lang.javas cript, dhtml wrote:

>On Nov 13, 11:42 am, John G Harris <j...@nospam.de mon.co.ukwrote:

>On Wed, 12 Nov 2008 at 18:28:42, in comp.lang.javas cript, 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
>'setPrototypeP roperty'.

<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