javascript: can I define a "private" variable using prototype?

Question

I want to use a unique private variable for each "instance" (I hope that this is the right term in Javascript), but both instances appear to use the same private variable.

func = function(myName)
{
    this.name = myName
    secret = myName

    func.prototype.tellSecret = function()
    {   return "the secret of "+this.name+" is "+secret
    }
}

f1 = new func("f_One")
f3 = new func("f_3")

console.log(f3.tellSecret()) // "the secret of f_3 is f_3" OK
console.log(f1.tellSecret()) // "the secret of f_One is f_3" (not OK for me)

I saw a solution but

this would mean duplicating the function on every instance, and the function lives on the instance, not on the prototype.

Another author says about the same solution

That's still not quite traditional classly Javascript, which would define the methods only once on Account.prototype.

So, is there a solution where

every instance can have unique values for secret
secret is only accessible for methods that are defined in the constructor and
functions are not duplicated for every instance

?

`secret = myName` -> `let secret = myName` or `const secret = myName`. You're currently assigning to a single global. — VLAZ, Jun 12 '20 at 15:08
@VLAZ just adding that won't work since the prototype method is overwritten in each call to `new func` — adiga, Jun 12 '20 at 15:12
@adiga yeah, I realised that later. I've retracted my close vote. I misread the question initially. — VLAZ, Jun 12 '20 at 15:13
You need to move the `func.prototype.tellSecret` method outside and make a way to get the `secret` value outside (like in the question you've linked) — adiga, Jun 12 '20 at 15:15
@VLAZ tbh I was also confused about that for two full minutes — adiga, Jun 12 '20 at 15:18
@adiga, ...a way to get the `secret` value outside... In the examples that I linked to, this is done by a function that is created for each instance. But it might be a good idea if tellSecret is a very heavy function. — Co Stuifbergen, Jun 12 '20 at 17:22

T.J. Crowder · Accepted Answer · 2020-06-12T15:20:10.347

The problem is that you're replacing your prototype function each time the constructor is called.

With old-style closure-based privacy, you can't access "private" members from prototype methods, because only functions defined in the constructor closing over them can use them. So you end up remaking the functions for each instance (which isn't as bad as it sounds, but isn't great).

function Example(name) {
    this.name = name;
    var secret = name; // Using `var` here on the basis this is ES5-level code

    // This can't be a prototype function
    this.tellSecret = function() {
        return "the secret of " + this.name + " is " + secret;
    };
}

Two options for you:

1) Use a transpiler like Babel, class syntax, and private fields (likely to be in ES2021, in use for a fair bit time now via transpiling):

class Example {
    #secret;

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

    tellSecret() {
        return "the secret of " + this.name + " is " + this.#secret;
    }
}

const f1 = new Example("f_One");
const f3 = new Example("f_3");

console.log(f3.tellSecret()) // "the secret of f_3 is f_3"
console.log(f1.tellSecret()) // "the secret of f_One is f_One"

2) Use a WeakMap (ES2015+) containing the secret information

const secrets = new WeakMap();
class Example {
    constructor(name) {
        this.name = name;
        secrets.set(this, name);
    }

    tellSecret() {
        return "the secret of " + this.name + " is " + secrets.get(this);
    }
}

const f1 = new Example("f_One");
const f3 = new Example("f_3");

console.log(f3.tellSecret()) // "the secret of f_3 is f_3"
console.log(f1.tellSecret()) // "the secret of f_One is f_One"

You put secrets where only Example has access to it.

You can use a WeakMap without using class syntax too, but if you're creating constructor functions with associated prototypes, class is simpler than function Example and assigning to properties on Example.prototype.

It didn't occur to me to use a WeakMap like this. Makes perfect sense in retrospect but still. Very nice solution. Also, the private fields are available in Chrome right now but not in Firefox yet. — VLAZ, Jun 12 '20 at 15:19
@VLAZ - :-) Not original to me, it was one of the motivations for `WeakMap` if I'm not mistaken. And yeah, we're **so close** to them moving to Stage 4. That's why I'm sure they'll be in the editor's draft spec soon, and guaranteed to be well before the ES2021 cutoff. — T.J. Crowder, Jun 12 '20 at 15:20
Thank you T.J. Crowder! I think that WeakMap will work for me, I will have a look at Babel later. — Co Stuifbergen, Jun 12 '20 at 17:16

javascript: can I define a "private" variable using prototype?

1 Answers1