Velocity Reviews > Functions and assignment precedence question

# Functions and assignment precedence question

Uncle Roastie
Guest
Posts: n/a

 09-02-2011
var decoratedFib = function fib(n) {
return decoratedFib(n-1) + decoratedFib(n-2);
}.decorate({...});

My question:
Does "decoratedFib" get assigned "function fib" or
the result of executing "function decorate"?

Richard Cornford
Guest
Posts: n/a

 09-02-2011
On Sep 2, 4:43 pm, Uncle Roastie wrote:
> var decoratedFib = function fib(n) {
> return decoratedFib(n-1) + decoratedFib(n-2);
>
> }.decorate({...});
>
> My question:
> Does "decoratedFib" get assigned "function fib"

No.

> or
> the result of executing "function decorate"?

If you mean the result of calling a 'decorate' method of the function
object created by the preceding expression (and assuming one of the
Function or Object prototypes has a 'decorate' method) then the value
assigned to - decoratedFib - is the return value from the call to that
method.

Richard.

Scott Sauyet
Guest
Posts: n/a

 09-06-2011
Uncle Roastie wrote:
> var decoratedFib = function fib(n) {
> * * return decoratedFib(n-1) + decoratedFib(n-2);
>
> }.decorate({...});
>
> My question:
> Does "decoratedFib" get assigned "function fib" or
> the result of executing "function decorate"?

Richard Cornford's answer is correct, but it's not as clear as his
prose usually is.

If you look at Javascript's operator precedence ([1]), you might note
that the member operator (".") binds well before the assignment
operator ("="), so anything of this form:

var z = x.y()

will assign to `z` the value of calling the function assigned to the
property `y` of the object `x` in the context of `x`. The fact that
in this case `x` is a function doesn't change that.

So your `decoratedFib` variable will be assigned the result of the
call to `decorate` performed on the named anonymous (!!) function.
The only way that will work is if `decorate` has been added to the
prototype chain of the anonymous function, that is, if it's on
Function.prototype (or possibly Object.prototype).

If decorate looked like this:

Function.prototype.decorate= function() {
var cache = {}, self = this;
return function(n) {
return (n in cache) ? cache[n] : (cache[n] = self(n));
};
};

then you would have a new Fibonacci function that memoized the
results, calculating larger ones much more quickly than the
undecorated version. Of course, then `decorate` should probably be
renamed `memoize`. (Note too that this is not a general-purpose
memoization function. It only works for unary functions of numbers or
strings. It's not hard to build a more general-purpose one, but it's
outside the scope of this discussion.

-- Scott

[1] One good source is https://developer.mozilla.org/en/Jav...tor_Precedence

Dr J R Stockton
Guest
Posts: n/a

 09-07-2011
In comp.lang.javascript message <06defdf6-cb61-42b3-8e26-524e673f7ff1@t3
g2000vbe.googlegroups.com>, Tue, 6 Sep 2011 05:24:36, Scott Sauyet
<(E-Mail Removed)> posted:

>
>then you would have a new Fibonacci function that memoized the
>results, calculating larger ones much more quickly than the
>undecorated version.

I have a couple of other examples where cacheing helps (with less subtle
code) at <http://www.merlyn.demon.co.uk/js-misc0.htm#Cash>.

--
(c) John Stockton, nr London UK. ?@merlyn.demon.co.uk IE8 FF3 Op12 Sf5 Cr12
news:comp.lang.javascript FAQ <http://www.jibbering.com/faq/index.html>.
<http://www.merlyn.demon.co.uk/js-index.htm> jscr maths, dates, sources.