Javascript - how do you add properties to an object constructor function

Question

How do I add properties to a constructor function in JavaScript? For example. If I have the following function.

function Hotel(name)
{
   this.name = name;
};

var hotel1 = new Hotel('Park');

can I add a "local" variable that can be used locally within the class as if it were private with the same notation using the keyword "this". Of course it would not be private since objects created will be able to use it correct?

Can I do something like this. Do I use the this keyword or do I use the var keyword which one is it? I have example 2 on the function constructor on the bottom

1. var numRooms = 40;
2. this.numRooms = 40;
3. numRooms : 40,

function Hotel(name)
{
   this.name = name;
   this.numRooms = 40;
};

I know that if I want a function within the object constructor I need to use the this word. Will that work as well for normal variables as I have asked above.

function Hotel(name)
{
   this.name = name;
   this.numRooms = 40;

   this.addNumRoomsPlusFive = function()
   {
       return this.numRooms + 5;
   }

};

Answer 1

Javascript historically creates objects from prototypes of other objects. It was a result of EMCA2015, that you have a distinct syntax of a class that specifies an object. As an aside, if you mouse over the table in that link it gives dates of when the feature was implemented.

A javascript object created by the new operator is more or less a combination of an associative array ( what you make with let avar={}; ) that can access the function level scopes it is defined in. The keys of the array are its properties. According to its creator, Javascript was created to be an easy to use program language without a hierarchy of types. One of the ways it accomplished this is by more or less considering its mapping type to be equivalent to the prototypical Object which object oriented programming languages describe.

Adding properties in 2022

function AProtoype(arg1, arg2, arg3){
    //this defines a property
    this.pa=arg1;
    /* unicorns in this section */
    let x = 1;
    /*    
    a getter which has the same syntax as a property
    but returns x from the scope which it references and
    not the object.
    */
    get getx() => x;
}
let object = new AProtoype(2,3,4);

Is equivalent to the following code for the purposes of data access but not inheritance and typing. The new operator also sets variables on an object that are used for these purposes.

function NewObject(arg1, arg2, arg3){
   let prototype = {};
   /*dragons in this section, as you are not using the this keyword to accomplish things*/
   prototype.pa = arg1;
   Object.defineProperty(prototype, "getx", {get:()=>x});
   return prototype;
}
//If you do this instead of using the new operator it is an anti-pattern.
//And like all anti-patterns: "But it works!"
let object = NewObject(2,3,4);

The relevant property defining methods where in some sense supported as early as 2010, 2011. I do not have a contemporary source to that time to confirm if you could pull off what I'm doing though, and you'd only want to if all else failed and it needed to run on Internet Explorer 9. In the event all else is failing, you may want to read the documentation for Object.create, which is also of interest because more or less provides an api to make new objects.

Now, for a fun time and horror, you can also define a function that returns this, and get an object back with an equivalent binding of that function. The horror comes when it is an object in global scope, and you rename a property of that object; as Javascript will resolve the name collision by happily writing on whatever it finds if it can. You can then use this to re-implement the prototype pattern that javascripts new operator is built off of conceptually, for the sake of science.

Answer 2

can I add a "local" variable that can be used locally within the class as if it were private with the same notation using the keyword "this".

Yes we can:

// API implementation in the library
function Hotel(name) {
  // only our library code knows about the actual value
  const numRooms = 'privateNoRoomsVar';

  this.name = name;
  this[numRooms] = 40;

  this.addNumRoomsPlusFive = function() {
    return this[numRooms] + 5;
  }

};

// from the library user's perspective
const hotel = new Hotel('Transylvania');
console.log('rooms+5 =', hotel.addNumRoomsPlusFive());

console.log('hotel.numRooms =', hotel.numRooms); // undefined
// also, users don't have access to 'numRooms' variable so they can't use hotel[numRooms].

If a user looks at the source code and finds out the value privateNoRoomsVar, then they can misuse the API.
For that we need to use symobls:

// API implementation in the library
function Hotel(name) {
  // no one can duplicate a symbol so the variable is really private
  const numRooms = Symbol();

  this.name = name;
  this[numRooms] = 40;

  this.addNumRoomsPlusFive = function() {
    return this[numRooms] + 5;
  }

};

// from the library user's perspective
const hotel = new Hotel('Transylvania');
console.log('rooms+5 =', hotel.addNumRoomsPlusFive());

console.log('hotel.numRooms =', hotel.numRooms); // undefined
// there is no way users will get access to the symbol object so the variable remains private.

---

Private class features, #privateField, are supported by all the browsers so we don’t have to worry about this anymore.

// API implementation in the library
class Hotel {
  // private field
  #numRooms = 40;

  constructor(name) {
    this.name = name;
  }

  addNumRoomsPlusFive() {
    return this.#numRooms + 5;
  }
};

// from the library user's perspective
const hotel = new Hotel('Transylvania');
console.log('rooms+5 =', hotel.addNumRoomsPlusFive());

console.log('hotel.numRooms =', hotel.numRooms); // undefined
//console.log('hotel.numRooms =', hotel.#numRooms); // throws error

Answer 3

When you use a "constructor function" in Javascript, any properties defined on the instance using the this keyword become public. This is unavoidable, because Javascript objects have no concept of private properties - if it exists, it can be accessed directly as object.property.

For example, if you tried to do as in the following snippet, mimicking a typical getter/setter pattern with a private variable in Java or C# (note that even if this worked, this is not idiomatic Javascript):

function MyObject(privateVar) {
  this.privateVar = privateVar;
}

MyObject.prototype.getVar = function() {
  return this.privateVar;
};

MyObject.prototype.setVar = function(newVal) {
  this.privateVar = newVal;
};

then while you can indeed use the getter and setter to do as you expect, you can also just access and set the private variable directly! Demonstration:

function MyObject(privateVar) {
  this.privateVar = privateVar;
}

MyObject.prototype.getVar = function() {
  return this.privateVar;
};

MyObject.prototype.setVar = function(newVal) {
  this.privateVar = newVal;
};

var obj = new MyObject(1);

// using public getter/setter
console.log(obj.getVar()); // 1
obj.setVar(2);
console.log(obj.getVar()); // 2

// using private variable directly - not intended to work
console.log(obj.privateVar); // 2
obj.privateVar = 3;
console.log(obj.getVar()); // 3 (using public API to get it to show that the direct update to the private variable also affects the intended public methods)

There is though a way to mimic the effect of private variables. They're not actually object properties - because, as I have just demonstrated, such are intrinsically public - but the same can be mimicked by:

• not using a "constructor function" at all, but a regular function that happens to return an object. This is all a constructor function really does, anyway - the difference in JS is only syntactic, that you do not need to use the new keyword when you call the function. (Although you still can, if you really prefer - any function that returns an object can be called with new and behave in the same way as without it, although performance will likely suffer a little as the function would then construct a brand new object and throw it away. See MDN for a justification of these statements, particularly step 4.)
• inside this function, using a regular variable as the private variable. This variable will be completely inaccessible from outside by the simple rules of scope, but you can still have the returned object retain access to it by the "magic" of closures.

Here is the above getter/setter example translated to this procedure, as well as demonstrations of it working. (I hasten to add again though, that this wouldn't be considered idiomatic code in Javascript.)

function makeObjectWithPrivateVar(privateVar) {
  function getPrivateVar() {
    return privateVar;
  }

  function setPrivateVar(newVal) {
    privateVar = newVal;
  }

  return { getPrivateVar, setPrivateVar };
}

var obj = makeObjectWithPrivateVar(1);

// getter
console.log(obj.getPrivateVar()); // 1
// setter
obj.setPrivateVar(2);
// getter again to observe the change
console.log(obj.getPrivateVar()); // 2

// but how could we access the private var directly??
// answer, we can't
console.log(obj.privateVar); // undefined
console.log(privateVar); // ReferenceError, privateVar is not in scope!

Note finally though that it's rare in modern Javascript to use the function-based constructors in this style, since the class keyword makes it easier to mimic traditional class-based languages like Java if you really want to. And in particular, more recent browsers support private properties directly (you just have to prefix the property name with a #), so the initial code snippet translated into a class and using this feature, will work fine:

class MyObject {
  #privateVar

  constructor(privateVar) {
    this.#privateVar = privateVar;
  }
  
  getVar() {
    return this.#privateVar;
  }
  
  setVar(newVal) {
    this.#privateVar = newVal;
  }
}


var obj = new MyObject(1);

// using public getter/setter
console.log(obj.getVar()); // 1
obj.setVar(2);
console.log(obj.getVar()); // 2

// using private variable directly - now doesn't work
console.log(obj.privateVar); // undefined, it doesn't exist
// console.log(obj.#privateVar); // error as it's explicitly private, uncomment to see error message

Answer 4

Usually it's performed using closures:

var Hotel = (function() {
      var numrooms=40; // some kind of private static variable

      return function(name) { // constructor
         this.numrooms = numrooms;
         this.name = name;
      };
}());

var instance = new Hotel("myname");

Answer 5

You can simple add a private variable to your constructor:

function Hotel(name) {

    var private = 'private';

    this.name = name;
};

But if you will use your Hotel function without a new operator, all properties and functions which was attached to this will become global.

function Hotel(name) {

    var private = 'private';

    this.name = name;
};

var hotel = Hotel('test');

console.log(name); // test

It is good idea to return an object in constructor function:

function Hotel(name) {

    var 
        private_var = 'private',
        private_func = function() {

            // your code
        };

    retur {

        name: 'name',
        public_func: private_func
    }
};

var hotel = Hotel('test');

console.log(name); // undefined

So if you will use Hotel constructor without new operator no global variable will be created. This is possible only if the return value is an object. Otherwise, if you try to return anything that is not an object, the constructor will proceed with its usual behaviour and return this.