current community

your communities

more stack exchange communities

Stack Exchange
tour help
Take the 2-minute tour ×
Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. It's 100% free, no registration required.
up vote 0 down vote favorite

There are several ways to reach the same end point in JS, for example:

(function (foo, bar) {
  return {run: function () {return foo(bar);}};
} (foo, bar));

(function (foo, bar) {
  return (function(foo, bar) { return {run: function () { return foo(bar); }}} (foo, bar))
} (foo, bar))

(function (foo, bar) {
  var Fizz = function (foo, bar)  { this.run = function () { return foo(bar); }; };
  return new Fizz(foo, bar) 
} (foo, bar))

Now for these, I know that one difference is that the prototype in the third case for the returned object would be different, but other than that, all three paths lead to an object which provides the same api. And since Javascript is a duct typed language, what a thing is is usually defined by its behavior.

Are there any other implications of choosing any one approach of the three that I am ignoring ?

share|improve this question

1 Answer 1

up vote 1 down vote

The only difference between the first two is the depth of the stack(though it's not outright impossible to optimize that away), since the only difference is the amount of scopes you are creating. Notice that you can continue creating as many scopes as you whim:

(function (foo, bar) {
        return (function(foo, bar) {
                return (function(foo, bar) {
                        return (function(foo, bar) {
                                return (function(foo, bar) {
                                        return (function(foo, bar) {
                                                return {run: function () { return foo(bar); }}
                                        } (foo, bar))
                                } (foo, bar))
                        } (foo, bar))
                } (foo, bar))
        } (foo, bar))
} (foo, bar))

Behind the scenes, a JavaScript function keeps a pointer to it's lexical scope, so the more scopes you create the more deep you'll have to go up in the scope of the function you put in the run field of the object. Again, this might be optimized away and has no effect on the logic since JavaScript function objects do not provide you with a way to access that scope(though a JavaScript implementation might add such a field)

share|improve this answer
    
this seems complicated ..:o –  Avinash Babu May 26 at 4:27

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.