JavaScript Closures for Dummies & JavaScript prototype, closures and OOP.

JavaScript Closures for
Dummies
by Morris Johns
http://blog.morrisjohns.com/javascript_closures_for_dummies

scope
Variables have each function scopes.
not in any functions, global variable

closures
a closure is a stack-frame which is not dealloctated
when the funtion returns. (as if a 'stack-frame'
were malloc'ed instead of being on the stack!)
In JavaScript, if you use the function keyword
inside another function, you are creating a closure.
as soon as there are no more references to the
function that is using the closure, the function/
closures should be garbage collected.

comparative
C pointer
- a pointer to a function
JavaScript reference
- a pointer to a function &
a hidden pointer to a closure

example 3
function say667()
{
// Local variable that ends up within closure
var num = 666;
var sayAlert = function() { alert(num); }
num++;
return sayAlert;
}
This example shows that the local variables are not copied - they
are kept by reference. It is kind of like keeping a stack-frame in
memory when the outer function exits

example 4
function setupSomeGlobals()
{
// Local variable that ends up within closure
var num = 666;
// Store some references to functions as global variables
gAlertNumber = function() { alert(num); }
gIncreaseNumber = function() { num++; }
gSetNumber = function(x) { num = x; }
}
All three global functions have a common reference to the same
closure because they are all declared within a single call to
setupSomeGlobals().

JavaScript
prototype, closures and OOP
by Jin Hwa Kim

inheritance
In prototype-based programming, objects can be deﬁned
directly from other objects without the need to deﬁne any
classes, in which case this feature is called differential
inheritance.
Differential Inheritance is a common inheritance model used by
prototype-based programming languages such as JavaScript, Io
and NewtonScript. It operates on the principle that most objects
are derived from other, more general objects, and only differ in a
few small aspects; while usually maintaining a list of pointers
internally to other objects which the object differs from.
from wikipedia

// Definition of constructor
var Duck = function() {
var kind = "duck";
this.shape = "beige feathered duck";
this.describe = function(){ console.log( this.shape ) };
// Overriding, surely.
this.fly = function(){ console.log( kind + " can't fly." ); };
};
Duck.prototype = Bird; // not worked
Duck.prototype = new Bird();
var dornald = new Duck();
dornald.describe(); // beige feathered duck
dornald.fly(); // duck can't fly.
dornald.sing(); // lalala.

// Polymorphism
var birds = [ angrybird, dornald, scrooge ];
for( var i in birds )
{
birds[i].fly(); // bird do fly.n duck can't fly.n duck can't fly.
}

var sum = 0;
function add_t() {
var sum = sum + 20;
}
add_t();
alert( ++sum );

use case 1
Prototype's bind() function or Dojo's dojo.lang.hitch() function
use closures.
Inside the function the this keyword becomes a reference to
that scope. The same function can behave differently
depending on its execution scopre.
Prototype can guarantee that your function will execute with
the object you want under the this keyword just by invoking
bind on it.
from Prototype JavaScript framework: Function.bind
(http://www.prototypejs.org/api/function/bind)

use case 2
LCMCalculator.prototype = { ...
gcd: function () {
var a = Math.abs(this.a), b = Math.abs(this.b), t;
if (a < b) { t = b; b = a; a = t; }
while (b !== 0) { t = b; b = a % b; a = t; }
this['gcd'] = function() { return a; };
return a;
} ... };
Only need to calculate GCD once, so "redefine" this method. (Actually
not redefinition - it's defined on the instance itself, so that this.gcd
refers to this "redefinition" instead of LCMCalculator.prototype.gcd.)
from wikipedia

JavaScript Closures for Dummies & JavaScript prototype, closures and OOP.

More Related Content

What's hot (20)

Viewers also liked (6)

Similar to JavaScript Closures for Dummies & JavaScript prototype, closures and OOP. (20)

Recently uploaded (20)

JavaScript Closures for Dummies & JavaScript prototype, closures and OOP.