Private methods in Javascript classes

JavaScript does not implement object-oriented programming in the same way as languages ​​like Java, C#, etc. In JavaScript, there is basically no concept of encapsulation . Even so, due to its great flexibility you can simulate it with some ingenuity.

Referencing variables/functions

It is the simplest and most practical. You create the functions or variables outside the class and the references inside the class.

class User {
	publico () {
  	console.log('Soy un método público');
    privado(); // se ejecuta correctamente
  }
}

let pepito = new User();
pepito.publico();
pepito.privado(); // pepito.privado is not a function

function privado () {
    console.log('Soy un método privado');
}

Using Factories

Remember: in Javascript there is no concept of classes . Even in ES6 and the arrival of the reserved word classstill doesn't exist as such. JavaScript is a prototyping language . Even if you use the new syntax to create "classes" , you will still be creating functions with a prototype.

This form is the one that is usually used when you want to implement private variables or methods. The trick is to return an object that references variables and/or local methods of the function in the object to be returned. This is the magic of the closures.

function User () {
  const privado = function () {
    console.log('Soy un método privado');
  }
  
  return {
    publico () {
      console.log('Soy un método público');
      privado(); // se ejecuta correctamente
    }
  }
}

let pepito = User();
pepito.publico();
pepito.privado(); // pepito.privado is not a function

Try this,

class User {
  constructor(name, password, email) {
		this.name     = name;
		this.password = password;
		this.email    = email;
        var privado_ = function(){
          console.log('realmente esto es privado');
        };
    
       this.privado = function(){
  	      console.log("Accediste a un metodo privado");
          privado_();
       }
  }

}

var u = new User("usuario","123","[email protected]");
u.privado();

Although I liked @jolsalazar's answer and it seemed quite practical, I want to leave the way I solved this and that seems a bit more 'elegant' to me:

var Salute = (function (){

    // Esta función es nuestro constructor
    function Salute(lang){
        this._lang = lang;
    }

    // Este es nuestro método privado
    function Hi(){
        if(this._lang == "en"){
            alert('Hi, I am a private method');
        }else if(this._lang == "es"){
            alert('Hola, Yo soy un método privado');
        }
    }

    // Este es nuestro método público
    Salute.prototype.sayHi = function () {
        return Hi.call(this);
    }

    return Salute;

})();

var salute_es = new Salute('es');

salute_es.Hi(); 
// La consola nos mostrará que Hi(); 
// no es una función válida

salute_es.sayHi();  
// Nos saldrá un alert con el texto 
// 'Hola, Yo soy un método privado'

Let me explain my code a bit:

We create an ' object ' with a self invoking function and use the method prototypeto 'inject' a new function and make it 'public' by passing the context as an argument to the call function.this

It should be noted that javascriptthere are no reserved words such as publicor privateto define methods within one Classand for this reason a type of 'hack' must be carried out as shown above.

Although JavaScript is not an Object Oriented language, we can get closer considering the definition of a private method.

Private methods are those methods that can be called from methods of the class, but never from outside the class.

The first thing to do is omit the this keyword from the constructor.

We define the private(); and a public method called method(); which invokes the private methods and this will be the one that we can call from external javascript methods.

In this way, remember that variables and methods with this are public and with var they are private.

class User {
 
 constructor(name, password, email) {
		var name     = name;
		var password = password;
		var email    = email;
        var privado  = function() { 
          console.log("Accediste a un metodo privado"); 
        }
        
        this.getPrivado = function(){ privado(); }
  }
  
}

var u = new User("usuario","123","[email protected]");
u.getPrivado();

Something that works very well is to implement class members with # in front

export class Ceil
{
    // miembros privados
    #intm = 0;
    #intn = 0;
    #inta = 0;

    constructor (intm, intn, inta)
    {
        this.#intm = intm;
        this.#intn = intn;
        this.#inta = inta;
    }

    // metodo publico
    printNumCeil = () =>
    {
        var intHorCeil;
        var intVertCeil;

        intHorCeil = this.#getNumCeil(this.#intm, this.#inta);
        intVertCeil = this.#getNumCeil(this.#intn, this.#inta);

        console.log(intHorCeil * intVertCeil);
    };

    // metodo privado
    #getNumCeil = (intDimCeil, intDimArea) =>
    {
        return (intDimArea + intDimCeil - 1) / intDimArea;
    }; 
}