Javascript function implementation variation

Question

If i need to write a java script function that takes an argument and returns a function that returns that argument, i can think of following two implementations. Are both of these same ? or there is anything different technically ? Both works and returns the same result.

/*Implemenation 1*/
function myWieredFunc(arg){
    var retf=function inner(){
        return arg;
    };
    return retf;
}

/* Implemenation 2 */
function myWieredFunc(arg){
    return function(){
        return arg;
    };
}

To use these:

 var f = myWieredFunc(84);       
 alert(f());

And even in the first example, you don't need to name the inner function ("inner") at all — Ian
– Ian, Commented Feb 8, 2014 at 23:48

Blake Regalia · Accepted Answer · 2014-02-08 23:54:20Z

1

This would be the way to write it

function wrap(arg) {
    return function() {
        return arg;
    };
};

If you wanted to make it more flexible you could allow multiple arguments:

function wrap() {
    var args = arguments;
    return function() {
        return args;
    };
};

var later = wrap('hello', 'world');
var result = later();
console.log(result); // ["hello", "world"]

answered Feb 8, 2014 at 23:54

Blake Regalia

2,7662 gold badges22 silver badges30 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

user2864740 · Accepted Answer · 2014-02-09 00:43:17Z

There is no reason for the variable in the code shown - functions are objects are values. As you've shown this means that function-objects can be assigned to a variable which is later evaluated and returned, or returned directly from the Function Expression.

As such, both forms are generally held equivalent and the closure over arg is unaffected.

However, in the first form..

Function.toString and stack-traces will normally include the function name, this makes "named functions", as in the first example sometimes more useful in debugging. Additionally, Firefox will expose function names - e.g. "inner" - through the non-standard Function.name property. (The function name can be specified without the use of the retf variable.)
Two additional bindings are introduced - retf in the outer function and inner in the inner function. These variables could be observed in the the applicable scope when stopping via a break-point - but are not otherwise accessible in the code shown.

jeff_kile · Accepted Answer · 2014-02-08 23:43:03Z

0

They are the same thing, the second is using an "Anonymous" function which just means its a function that is not given a name or assigned to a variable.

answered Feb 8, 2014 at 23:43

jeff_kile

1,83516 silver badges21 bronze badges

Collectives™ on Stack Overflow

Javascript function implementation variation

3 Answers 3

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related