But that variable *is* private. You’re not changing or accessing a variable. What you’re doing is overwriting the whole function.

http://jsfiddle.net/Px4Nq/1/
It may not be a common example, but it illustrates the point.

I’m certainly not saying closures are not elegant and powerful when used properly. But they can cause irksome memory leaks when you don’t pay careful attention to what you are doing. I’ve definitely caused problems for myself this way. But obviously it’s my lack of knowledge, not the closures themselves, that’s the problem. 🙂 I’d still much rather have them than not.

@DJW – Messy closures? The moment Javascript became my favorite programming language was when I learned about closures (or function scope.) Javascript’s closure/scope works as a function call stack, with each function call being saved in memory (this is what makes scope possible and other things like recursion, and currying.) Every function instance has access to its own declared variables and to it’s parent’s variables, and it’s parent’s parent, and so on.

@Stoimen – Good test though. I really like how you’re displaying your results. The graphs look really good.

Thanks for the comment, I’m glad you like the quiz series!

I get what you mean, though. It is possible to mimic the functionality of private functions and variables using closures. In that sense you can have them in JS. But I hope you’d agree that it’s not the same thing – and not nearly as simple – as most OO languages. I would give just about anything to be able to have a “private” and “protected” keyword in JS that functioned the same way as in Java.

Quiz results are interesting, though. It’s nice to see what the general consensus about these things is. Nice idea. The various different graphs are fun, too 🙂

// this object is global
var f = function() { return 'hello world!' };

function g() 
{
        // f is public here, cause is global
	return "g: " + f();
}

// hello world
console.log(f());
// g: hello world
console.log(g());

function h()
{
        // f is private here, cause it's defined into h()
	var f = function() {
		return 'goodbye world';
	}

	return "h: " + f();
}

// hello world
console.log(f());
// h: goodbye world
console.log(h());

You can also take a look at one of my older articles: OOP JavaScript: Accessing Public Methods in Private Methods