CODEWITHSUNDEEP
javascriptpublic-method
Blankman
Blankman

Reputation: 267180

Why are these methods public?

My javascript looks like the following. I don't understand why these methods are all public though?

Something.RegisterNamespace("One.ABC");

    (function(ABC) {

      ABC.SayHello = function() {
             alert('hello');

      };

    })(One.ABC);

So now I can do:

One.ABC.SayHello();

Upvotes: 2

Views: 232

Answers (6)

Brian Moeskau
Brian Moeskau

Reputation: 20431

You are adding the SayHello function into the object being passed in, which is One.ABC. What else are you expecting? If you want a private function, define it inside your anonymous function (var SayHello = function(){...}) without adding it to the object. Not sure what you're trying to accomplish...

EDIT:

Here's how I would rewrite your code to do what I think you want:

One = {};
One.ABC = {};

(function(ABC) {
    var PrivateHello = function(){
        alert('hello');
    };
    ABC.PublicHello = function() {
        PrivateHello();
    };
})(One.ABC);

One.ABC.PublicHello(); // alerts 'hello'
One.ABC.PrivateHello(); // error 'One.ABC.PrivateHello is not a function'

Upvotes: 1

KooiInc
KooiInc

Reputation: 122956

Your code can also be written as:

var One = {
      ABC:{
       SayHello: function() {
         alert('hello');
       }
      }
};
One.ABC.SayHello(); //=> hello

This variable definition creates a (pseudo) namespace One (actually, an Object in the global namespace). The first property of One is ABC. ABC is an Object too and has one property, the public methodSayHello. If you wanted SayHello to be private, this could be a way to do it:

var Two = {
    ABC: ( function(){
        // SayHello is a private function within this
        // anonymous function 
        // it can only be accessed by a public method 
        // you create (here it's the method Hi)
        function SayHello() {
          alert('hello from Two.ABC');
        }
        return {
                SayHello: function(){alert('you are not allowed to say Hello!');},
                Hi: SayHello
               };
        } )()
    }
    Two.ABC.SayHello(); //=> you are not allowed to say Hello!
    Two.ABC.Hi(); //=> hello from Two.ABC

Now Two.ABC is an object too, but it is created using an anonymous constructor function instantiated on creation (a singleton pattern I think it's called). Within that constructor SayHello is now a private (not publicly accessible) function. You'll have to assign some public method to access SayHello (here: Two.ABC.Hi), otherwise it will be completely hidden. In this example, because SayHello is defined within the anonymous function scope, it is accessible for the methods that anonymous function returns, which in turn are accessible to the parent scopes (ABC and TWo). In other words, the function SayHello is enclosed by the methods the singleton returns.

Upvotes: 1

lincolnk
lincolnk

Reputation: 11238

all properties/objects of an object are public. the code sample you've posted is equivalent to 

Something.RegisterNamespace("One.ABC");
One.ABC.SayHello = function() { alert('hello'); };

here, you're defining the property SayHello to be a function that executes the alert statement when called.

edit: perhaps you're being thrown off by the structure of the code? this section

(function(ABC) {
  ABC.SayHello = function() {
         alert('hello');

  };

})(One.ABC);

is equivalent to 

function addHello(pObject) {
    pObject.SayHello = function() {
        alert('hello');
    };
}

addHello(One.ABC);

the only difference is that in your example, the function is being defined inline and then run immediately.

(...)(parameters);

defining it inline just make the function available for one-off use, where in my example you could use the same function to define a SayHello method for many objects.

Upvotes: 0

The Who
The Who

Reputation: 6622

RegisterNamespace is not standard JS. But that looks like it is creating an object "One" with a property of "ABC"

The anonymous function is binding its inner function to the object "One" via the property "ABC"

So you end up with:

var One = {"ABC" : { "SayHello" : function(){alert('hello')}}}

Upvotes: 0

ChaosPandion
ChaosPandion

Reputation: 78282

The only effective way to have private methods is by using a closure.

function MyClass() {
    var privateMethod = function() {
        return 0;
    };

    this.publicMethod = function() {
        return privateMethod();
    };
}

Upvotes: 2

Prabhu Murthi
Prabhu Murthi

Reputation: 2876

I hope the function's name and the Name space's name are same, so those can be referred as public

Upvotes: 0

Related Questions