Private JavaScript Methods

Sometimes, we need methods in our constructor that do some work only in the constructor. There might be some internal maintenance that needs to be done. We might simply want to protect some data, etc. We declare a private method by using an inner function.

function Horse(name) {
    let color = '';
    this.name = name;
    // Function property to set the color variable
    this.setColor = function(newColor) {
        color = newColor;
    }
    // Function property to get the color variable
    this.getColor = function(){
        return color;
    }
    // inner private function
    function runFast(){
        return 'Gallop';
    }
}

If we try to run the runFast() method, it will return an error…

let silver = new Horse('Silver');
silver.run();
Uncaught TypeError: silver.run is not a function

We can only run this private method from within the function constructor. So how do we get any data from the private method?

function Horse(name) {
    let color = '';
    this.name = name;
    // Function property to set the color variable
    this.setColor = function(newColor) {
        color = newColor;
    }
    // Function property to get the color variable
    this.getColor = function(){
        return color;
    }
    // Function to set the movement of the horse
    this.getMovement = run();
    function run(){
        return 'Gallop';
    }
}
silver.getMovement; // Returns 'Gallop'

So why do this? Why not simply have them access the run() method directly? The answer is an OOP principle called, ‘encapsulation’. We can protect the code by not having it accessed directly. We can then set up some logic in the code. For example, we could set up a method property where we pass data and then have IF statements that decide what private method to run. The advantage is the external code does not know or care about the internal logic. It just knows what is returned. This is how a lot of web APIs work.

Happy Coding!

Clay Hess