can you count the letter / in:
q: what are the benefits of using new over closures ive been programming in js for over a year now, mainly in angularjs. and i can honestly say ive never made a function use prototypical inheritance. when ever i need a class like object that has private data, i use the factory pattern and closures to create classes. i can honestly say ive never needed to use the this key word. 
im trying to learn node, and it uses prototypical inheritance pretty heavily so it seems. so there has to be a pretty big benefit of using it over closures.  can someone explain the main advantages of using prototypes and what not?

a: aside from being more familiar to c++/java programmers, the only advantage i can think of is that prototypes and constructors have arguably better support for traditional oop-style inheritance.
imagine you have class a with method foo(), and class b with method bar() that calls foo(). we want class b to be derived from a, so that it can simply call foo() directly and everything works. with constructors and prototypes, this is easy:
var a = function() {
    this.x = 42;
};
a.prototype.foo = function() {
    return this.x;
};

var b = function() {
    this.y = 7;
};
b.prototype = new a;
b.prototype.constructor = b;

b.prototype.bar = function() {
    return this.x * this.y;
};

var a = new a;
var b = new b;
console.log(a.foo()); // 42
console.log(b.foo()); // 42
console.log(b.bar()); // 294

with closures, you can use the mixin approach for public members and methods, but for privates youre basically stuck.
var a = function() {
    var x = 42;
    return {
        foo: function() {
            return x;
        }
    };
};

var b = function() {
    var y = 7;
    var obj = {
        bar: function() {
            return x * y;
        }
    };

    // mix in as public members
    var a = a();
    object.keys(a).foreach(function(key) {
        obj[key] = a[key];
    });
    return obj;
};

var a = a();
var b = b();
console.log(a.foo()); // 42
console.log(b.foo()); // 42
console.log(b.bar()); // uncaught referenceerror: x is not defined

as far as i can tell, the only way to make this snippet work is to make x public and use this.x, at which point it might as well not be using closures anymore. closures can implement private access, but not protected access, so if you want to do traditional inheritance you have to leave everything public anyway.
of course, if you dont do very much inheritance, this is a non-issue. at my job we hardly ever inherit from anything, so we also use closures by default.

user
The total number of "/"s in that passage is fifteen.
assistant