CODEWITHSUNDEEP
javascript
timebandit
timebandit

Reputation: 838

What is the correct way of calling an internal function using the module pattern in Javascript

I am new to Javascript and am still getting my head round the various ways of creating objects i.e constructor+new, prototypal, functional & parts.

I have created what I think is an object factory using the module pattern and want to know what the correct method of calling an internal method would be. Is it via this or function name.

Here is my module:

function chart() {
    function my() {
        // generate chart here, using `width` and `height`
    }

    my.sayHi = function(){
        console.log('hi');
        my.sayBye();
    };

    my.sayBye = function(){
        console.log('Bye');
    };

    return my;
    }

var test = chart();
test.sayHi();

You can see that the first function calls the second using my.sayBye() or is it better to use this.sayBye(). Both produce the same result and run without error.

Upvotes: 2

Views: 10157

Answers (2)

Aran Mulholland
Aran Mulholland

Reputation: 23935

The module pattern allows you to dispense with the 'this' variable if you want to. I would probably rewrite the above code to look like this and then the question becomes moot.

function chart() {
    var hiCount = 0;

    function sayHi(){
        console.log('hi');
        hiCount++;
        sayBye();
    };

    function sayBye(){
        console.log('Bye');
    };

    return {
       sayHi : sayHi,
       sayBye: sayBye
    };
}

var test = chart();
test.sayHi();

In the above code all is defined within the function chart. As JavaScript's scope is at the function level every time the chart function is called a new set of functions will be defined. And a new set of variables can also be defined that are private to the function as they are defined in the function and are not accessible from outside. I added hiCount as an example of how you could do this. The Module pattern allows privacy in JavaScript. It eats more memory than the prototype pattern though as each time a function is declared it is not shared between other instances of the same class. That is the price you have to pay in Javascript to have class variables that are private. I willingly pay it. Removing 'this' from my code makes it easier to understand and less likely that I will fall into problems of misplaced scope.

Upvotes: 5

Mohit
Mohit

Reputation: 559

Using "this" is better approach because you would be able to bind the function directly to the parent function object.And you dont need to return anything from the function. where as in your case you are explicitly returning another function Here is the use of "this" approach

function chart() {
 this.sayHi = function(){
    console.log('hi'); 
 }
}

var test = new chart();
test.sayHi();

Using this approach you would be able to call anything in the prototype of function "chart" Eg

chart.prototype.hello = function(){
 console.log('hello')
}

So you would be able to call the hello function from the same object(test)

Upvotes: 1

Related Questions