Private class in Javascript

Question

I’m looking for a way to make both attributes and methods invisible so they’re not accessible from outside the class. But I also wanted to use the modern approach to do this (class Nomeclass{}). After many attempts I made a different approach to everything I found: although it works exactly as I need it, and, in my view, it becomes much simpler and readable, I don’t know if this is valid and/ or conventional.

Can I do that? Or is there some convention that prohibits this kind of approach?

Watch the code carefully:

'use strict';
//O objetivo dessa class é tornar os dados restritos
function ExemplePrivate(value){
    var _value = value; //Privado
    
    this.set_value = function(val){
        //Poderá fazer uma validação antes
        _value = val;
    }
    this.get_value = function(){
        //Poderá fazer uma validação antes
        return _value;
    }
}

//Class filha que será pública
class ClassPublic extends ExemplePrivate{
    //adicional code
}

 
    var cPublic = new ClassPublic('A class filha foi <b>instanciada</b>');
    document.querySelector('#p1').innerHTML = cPublic.get_value();
    cPublic.set_value('A class filha foi <b>modificada</b>');
    document.querySelector('#p2').innerHTML = cPublic.get_value();
    
    // Note que o resultado é bloqueado
    document.querySelector('#p3').innerHTML += cPublic._value+".";

#p3{color:red}

<!-- Look in JS -->
<p id="p1"></p>
<p id="p2"></p>
<p id="p3"> O resultado para <b>cPublic._value</b> tem que ser <b>undefined</b> porque é invisível: </p>

Answer 1

Power, can. Do what you want? No undesirable effects? Only you can answer this. If you do everything correctly you can do it. If you’re not sure about this and you don’t do anything different, don’t do it. It goes for anything in programming. Never do anything if you are not absolutely sure if the result is exactly what you want, neither more nor less.

Don’t mind conventions that prohibit something. This is called "good practice" and look here on the website for what I think about it. You have to know why things, not conventions that tell you to do something.

I find this code ugly because it doesn’t use class on one side and use it on the other. If you want to make the class be private. I have my doubts if that’s what you want. And I think that you have some flaws in this code, but that’s a matter of opinion, because I’m not sure what you want and especially what you need that’s more important than what you want.

Have a good practice that says to use getter and Setter, only in languages of script It makes little or no sense.

If you want to scale class programming, where you need a private class you should use Typescript. Example code:

module Modulo {
    export class ClassePublica {
        private classePrivada : PrivateClass;
        constructor() {
            this.classePrivada = new ClassPrivada();
        }
        public teste() {
            this.classePrivada.teste();
        }
    }
    class ClassPrivada {
        public teste() {
            console.log('it works');
        }
    }
}

I put in the Github for future reference.

That in JS looks like this:

var Modulo;
(function (Modulo) {
    var ClassePublica = /** @class */ (function () {
        function ClassePublica() {
            this.classePrivada = new ClassPrivada();
        }
        ClassePublica.prototype.teste = function () {
            this.classePrivada.teste();
        };
        return ClassePublica;
    }());
    Modulo.ClassePublica = ClassePublica;
    var ClassPrivada = /** @class */ (function () {
        function ClassPrivada() {
        }
        ClassPrivada.prototype.teste = function () {
            console.log('it works');
        };
        return ClassPrivada;
    }());
})(Modulo || (Modulo = {}));

Answer 2

Module Pattern

From the description of the problem, where you want to separate the private part from the public part, maybe what you’re looking for is the Module Pattern or something similar. I’ve used a variation called Definitive Module Pattern because I think it makes the implementation clearer. In the link the author also explains how the original pattern works.

Using an example:

var module = (function () {

    function ClassePrivada () {
        this.valor = 30,
        this.setValor = function (val) {
          this.valor = val;  
        }
        this.getValor = function () {
          return this.valor;
        }
    }

    // private
    var _private = {
        valor: 10        
    };
    
    // public
    var _public = {
        getValor: function () { 
          return _private.valor
        },        
        setValor: function (val) {
          _private.valor = val;
        },
        getInstancia: function () {
          return new ClassePrivada();
        }
    };

    return _public;

})();


// funcoes privadas
console.log(module.getValor());
module.setValor(20);
console.log(module.getValor());

// classes privadas
var c = module.getInstancia();
console.log(c.getValor());
c.setValor(40);
console.log(c.getValor());

You can also create a module hierarchy that is interesting and allows you to better organize your code by creating a structure similar to namespaces.

If this is not exactly the kind of solution you are looking for, I hope it will help you in creating your solution.