¿Cuál es el inconveniente de crear verdaderos métodos privados en JavaScript?

De acuerdo con otros lenguajes de programación como c ++, java, etc., privado es algo que no se puede compartir con otras clases, a lo que no se puede acceder directamente usando objetos. La misma regla se aplica también a JavaScript.

Entonces, primero tenemos que ver cómo se crean los métodos privados usando JavaScript. Hay principalmente cuatro palabras clave con las que podemos hacer un método privado en la clase.

1. variable
2. dejar
3. constante
4. # (picadillo)

Ejemplo:

<script>
// class Geek
  var Geek = function (article, published) {
      // public member
      this.programmingLang = "Js";
  
      // private member
      var topic = "private_method";
      var status = published;
  
      // private member function
      var publish = () => {
          console.log(article);
          return status;
      }
  
      // calling private member 
      // function inside same class
      console.log(publish());
  };
  
  // Geek1 is object of Geek class
  var Geek1 = new Geek('ABC', 'YES');
  
  // calling public member outside the class
  console.log(Geek1.programmingLang);
<script/>

Producción:

ABC
YES
Js

Hay dos desventajas principales de crear el verdadero método privado en JavaScript.

1. No se puede llamar al método privado fuera de la clase.
2. Crear ineficiencia de memoria cuando se crean diferentes objetos para la misma clase, ya que se crearía una nueva copia del método para cada instancia.

Ejemplo:  si llamamos a una función miembro privada fuera de la clase, en ese caso da un error.

<script>
    var Geek = function (article, published) {
        this.programmingLang = "Js";
        var topic = "private_method";
        var status = published;
        var publish = () => {
            console.log(article);
            return status;
        }
        console.log(topic);
    };
    var Geek1 = new Geek('ABC', 'YES');
    console.log(Geek1.programmingLang);
    console.log(publish());
<script />

Producción:

Pero el siguiente ejemplo da el resultado correcto:

<script>  
  class A {
      // Private field
      #foo;
      constructor(foo) {
          this.#foo = "ABC";
      }
      #privateFun(prefix) {
          return prefix + this.#foo;
      }
      publicFun() {
          return this.#privateFun(">>");
      }
  }
  let a = new A();
  console.log(a.publicFun());
<script/>

Producción:

>>ABC                

Ejemplo: si creamos un objeto diferente para la misma clase, en ese caso cada objeto crea su propia instancia o, por ejemplo, una copia de la función para sí mismo. Entonces, en ese caso, surge el problema de la ineficiencia de la memoria.

<script>
    var Employee = function (name, comp, sal) {
        this.name = name;
        this.company = comp;
        this.salary = sal;
  
        // Private method
        var Sal_increase = () => {
            this.salary = this.salary + 45000;
        };
  
        // Public method
        this.dispalySal = () => {
            Sal_increase();
            console.log(this.salary);
        };
    };
  
    const A = new Employee("A", "dream", 45000);
    const B = new Employee("B", "young", 6000);
    const C = new Employee("C", "inspire", 9000);
  
    A.dispalySal()
    B.dispalySal()
    C.dispalySal()
</script>

Producción:

90000
51000
54000

Nota: El código aquí mencionado se puede ejecutar usando HTML interno o una consola.