Anvantage of self invoking function inside function definition

Question

whats the advantage of a function definition like this: obj = { func: function(){return function func(){return this.something;};}() }

Story: I was looking for a way how to rotate a Three.js Vector3 by a certain angle around an axis and found this: How to rotate a Three.js Vector3 around an axis? I was interested in how the function works and looked it up: https://github.com/mrdoob/three.js/blob/master/src/math/Vector3.js. The function looks like this:

applyAxisAngle: function () {

    var quaternion;

    return function applyAxisAngle( axis, angle ) {

        if ( quaternion === undefined ) quaternion = new Quaternion();

        return this.applyQuaternion( quaternion.setFromAxisAngle( axis, angle ) );

    };

}(),

So whats the reason for this way of the defining a function?

Considering position of `d` and `n`, `anvantage` is some typo — Rajesh, Oct 18 '16 at 12:17
advantage is to hide `quaternion`. `applyAxisAngle` can use it, but no one else. — Maxx, Oct 18 '16 at 12:18

score 2 · Accepted Answer · answered Oct 18 '16 at 12:19

The immediately-invoked function expression (IIFE) lets the author of that code give the applyAxisAngle function a truly private quaternion variable that nothing else anywhere can see.

That code basically does this:

var quaternion;

// ...

applyAxisAngle: function applyAxisAngle( axis, angle ) {

    if ( quaternion === undefined ) quaternion = new Quaternion();

    return this.applyQuaternion( quaternion.setFromAxisAngle( axis, angle ) );
},

...but keeping quaternion entirely private, rather than sharing it with code in the scope where all of this appears.

It defers constructing the Quaternion object until the first time it's called, and then it reuses that object in all subsequent calls by using the value from that private quaternion variable.

score 2 · Answer 2 · answered Oct 18 '16 at 16:03

Actually, the reason applyAxisAngle() was written that way was not to keep quaternion private, although that is, in fact, a side effect of the implementation.

It was written that way to avoid instantiating a new Quaternion() every time the method is called, and consequently, avoiding garbage collection.

applyAxisAngle() is often called in tight loops -- many times a second. Writing the method this way, the Quaternion is instantiated only once.

The implemented construct is called a "closure".

Anvantage of self invoking function inside function definition

2 Answers2