[Tutorial] Encapsulation & "static" - Object Oriented Programming

Even though its in the prototype chain above us, we cannot do super.#initDBConnection() for this...

Fun fact about private methods is that they're not inherited through the prototype chain like public methods are. Instead they're added directly to the instance during construction like fields. Because of this, you wouldn't be able to access a private member through super since that is reaching up in the prototype chain for a value which doesn't exist there.

It is, however, possible for subclass to access a private method through this. The difficulty is gaining access to the private name used to define the method. Private names are scoped to the class block in which they were defined. So if a subclass wants to have access to a private method defined by its superclass, it would also need to be defined within the scope of that superclass.

class Database {
    #initDBConnection() { // "#initDBConnection" name scoped to Database block
        console.log("Called: #initDBConnection()")
    }

    static { 
        class CustomDB extends Database {
            // During construction, Database adds #initDBConnection()
            // method to each new CustomDB instance as part of super()

            saveData () {
                this.#initDBConnection() // OK since "#initDBConnection" is in scope
            }
        }

        const db = new CustomDB()
        db.saveData() // Called: #initDBConnection()
    }
}

This scoping of the private name is what makes private members private. Being scoped to the class block prevents anything outside that class block from referring to that private member while at the same time allowing any code within it to have access - even if it is code not part of the class itself.

As I mentioned recently in the OO context, I can show you all about cloning of objects, if you are interested.

I have a procedure that will attach an attribute to an object such that the attribute will modify, to meet the object's needs, any value stored in it. Usually, the value would be a function, and the modification would be to bind it to the object. The reason to want to do that is to make the function (now a method) easy to use as a callback. One can write things like setTimeout(foo.bar) instead of setTimeout(() => foo.bar()).

Here is a unit test for the procedure to set up such attributes (assuming t is an object available for testing and u is an object available for utilities):

t.o0 = Object.create(null);
u.tgtKeyGroom(t.o0, 'greeting', string => `I said, ${string}`);
t.o1 = Object.create(t.o0);
t.threw = false;
t.failed = `Unit test failed!`;
try {
  t.o1.greeting
} catch (why) {
  t.threw = true;
  if (`What greeting?` !== why.message) throw Error(t.failed);
};
if (! t.threw) throw Error(t.failed);
t.o1.greeting = "Hello!";
if ("I said, Hello!" !== t.o1.greeting) throw Error(t.failed);
if ("I said, Hello!" !== t.o1.greeting) throw Error(t.failed);
t.o3 = Object.create(null);
u.tgtKeyGroom( t.o3, 'isAnOperatingThetan', function (raw) {
  return `Groomed to ${this.id}.`
});
t.o3.isAnOperatingThetan = true;
t.o4 = Object.create(t.o3);
t.o4.id = 'o4';
if ("Groomed to o4." !== t.o4.isAnOperatingThetan) throw Error(t.failed);