Example, lets say I have the following Constructor function defined in window global of a browser.
function AccessProperty() {
this.myName = "Chris";
}
Now I execute this function like this:
new AccessProperty();
Now based on how I executed the function above with the new keyword, how can I access this.myName property without adding something like this:
var acccess = new AccessProperty();
You can access it directly like this:
acccess.myName
or use the square brackets:
acccess['myName']
Without using the new operator
If you call that function without the new operator, the property will be set in the window object of the page. This is not very recommended, but you could do:
AccessProperty();
console.log(window.myName);
Another possibility is to return a new object like this:
function AccessProperty() {
return { myName: "Chris" };
}
var o = AccessProperty(); // not using 'new'
console.log(o.myName);
var acccess = new AccessProperty();"this will be undefined. I also don't think the OP has problems with using new but with assigning the return value to a variable. But tbh, the question doesn't make much sense to me ¯\_(ツ)_/¯.
It's really not clear what your ultimate goal is. this is a contextual reference that changes depending on the context of a function. When you use new, this refers to an object the js system creates for you and returns to the caller. Without new this will be the global window if you just call the function.
You can explicitly tell the function what this is with a function like call():
function AccessProperty() {
this.myName = "Chris";
}
let someObject = {}
AccessProperty.call(someObject) // this will be someObject
console.log(someObject.myName) // to which the function adds myName.But that's seems like the hard way to do something, when you could just use new and get an object with a myName property.
As a demonstration of the dynamic nature of this consider the code:
function AccessProperty() {
this.myName = "Chris";
}
let o = {
set: AccessProperty,
talk() {console.log(this.myName)}
}
// because of the way it's called `this` in
// the function AccessProperty will be
// the object o
o.set()
o.talk()
console.log(o) // o now has a myName propertyThis behavior is very useful in some situations, if you don't want that behavior you are required to use this you can just define variables.
this is a reference to some object, if it's not a reference to some object, then how can it have properties like myName? Are you sure you don't just want a variable: let myName = "Chris"?If you are not in strict mode you can do something like this
function AccessProperty(){
this.name="ram"
}
function parent(){
AccessProperty.bind(this)
AccessProperty()
console.log(this.name)
}
parent()
Here we have binded the scope of AccessProperty function to the scope of parent function. With this done the name will be in the scope of parent function
this inside parent will either be undefined in strict mode or window in non-strict mode. This only works accidentally because this is window. AccessProperty is not bound because you are not doing anything with the return value of bind (bind doesn't magically change AccessProperty itself). If you do parent.call({}) instead (forcing this to be an object other than window) you will see that it does not work.
(new AccessProperty()).myNamelike this?access.myNamenew AccessProperty()somewhere, then you cannot access that value. Can you provide more information?AccessPropertycan perform side effects and store the value in a different place. You could change the implementation ofAccessPropertytovar obj = {}; function AccessProperty() { obj.myName = "Chris"; }; new AccessProperty(); console.log(obj.myName);but I wouldn't advice doing that. It's hard to help without knowing the actually problem you are trying to solve.