i answered one question about closures here in SO with this sample:
function Constructor() {
var privateProperty = 'private';
var privateMethod = function(){
alert('called from public method');
};
return {
publicProperty: 'im public',
publicMethod: function(){
alert('called from public method');
},
getter: privateMethod
}
}
var myObj = new Constructor();
//public
var pubProp = myObj.publicProperty;
myObj.publicMethod();
myObj.getter();
//private - will cause errors
myObj.privateProperty
myObj.privateMethod
a user commented on my answer saying:
Also, if your function explicitly returns an object it is not a good practice to call it with new because that is misleading - if using new you'd expect the result to be an instance of Constructor
i usually create objects using new. but why is it not a good practice? it seems like using new and not using new returns the same thing. what is the proper way of creating objects from closures?
New keyword in JavaScript is used to create an instance of an object that has a constructor function. On calling the constructor function with 'new' operator, the following actions are taken: A new empty object is created.
Instantiation: The new keyword is a Java operator that creates the object. As discussed below, this is also known as instantiating a class. Initialization: The new operator is followed by a call to a constructor. For example, Point(23, 94) is a call to Point's only constructor.
The new keyword is used in javascript to create a object from a constructor function. The new keyword has to be placed before the constructor function call and will do the following things: Creates a new object. Sets the prototype of this object to the constructor function's prototype property.
Closures are important because they control what is and isn't in scope in a particular function, along with which variables are shared between sibling functions in the same containing scope.
No, it's not the same thing. Consider when using instanceof
:
function C1() {
return {};
}
function C2() {
}
var c1 = new C1();
var c2 = new C2();
alert(c1 instanceof C1); // false; wha...?
alert(c2 instanceof C2); // true, as you'd expect.
Here's a demo.
So instead, create them by assigning to this
, possibly with a safeguard to prevent forgotten new
s.
function Constructor() {
var privateProperty = 'private';
var privateMethod = function() {
alert('Called from private method');
};
this.publicProperty = "I'm public!";
this.publicMethod = function() {
alert('Called from public method');
};
this.getter = privateMethod;
}
Even better, use the prototype when possible:
function Constructor() {
var privateProperty = 'private';
var privateMethod = function() {
alert('Called from private method');
};
this.getter = privateMethod;
}
Constructor.prototype.publicProperty = "I'm public!";
Constructor.prototype.publicMethod = function() {
alert('Called from public method');
};
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With