Funciones estáticas privadas en javascript

Question

¿Cómo puedo crear una función que no se pueda llamar desde afuera?

var obj = { 
    function1: function(){ 
     alert("function1"); 
    }, 
    function2: function(){ 
     alert("function2..."); 
     obj.function1(); 
    } 
}; 
// so how to make this function unaccessible 
obj.function1(); 
// and you could only call this function 
obj.function2(); 

Answer 1

Es posible que desee considerar el uso de la Yahoo Module Pattern. Este es un patrón único, y los métodos no son muy estática, pero puede ser lo que buscas:

var obj = (function() { 

    //"private" variables: 
    var myPrivateVar = "I can be accessed only from within obj."; 

    //"private" method: 
    var myPrivateMethod = function() { 
     console.log("I can be accessed only from within obj"); 
    }; 

    return { 
     myPublicVar: "I'm accessible as obj.myPublicVar", 

     myPublicMethod: function() { 
     console.log("I'm accessible as obj.myPublicMethod"); 

     //Within obj, I can access "private" vars and methods: 
     console.log(myPrivateVar); 
     console.log(myPrivateMethod()); 
     } 
    }; 
})(); 

a definir sus miembros privados donde myPrivateVar y myPrivateMethod están definidos, y sus miembros públicos donde myPublicVar y myPublicMethod se definen.

Simplemente puede acceder a los métodos y propiedades públicas de la siguiente manera:

obj.myPublicMethod(); // Works 
obj.myPublicVar;   // Works 
obj.myPrivateMethod(); // Doesn't work - private 
obj.myPrivateVar;  // Doesn't work - private 

Answer 2

Puede utilizar un cierre, algo a lo largo de las líneas de ....

var construct = function() { 

    var obj = {}; 

    var method1 = function() { 
     alert("method1"); 
    } 

    obj.method2 = function() { 
     alert("method2..."); 
     method1(); 
    } 

    return obj; 
} 

obj = construct(); 

continuación:

obj.method2 es accesible, pero obj.method1 no existe para uso público. Solo se puede acceder usando las funciones miembro de la clase.

Answer 3

La respuesta simple es que no se pueden hacer ambos. Puede crear métodos "private" o "static", pero no puede crear Funciones estáticas privadas como en otros idiomas.

La forma en que puede emular la privacidad es cierre:

function f() { 

    function inner(){} 

    return { 
    publicFn: function() {}, 
    publicFn2: function() {} 
    } 
} 

aquí debido a cierre, la función inner se crea cada vez que se llama a f, y las funciones públicas puede acces esta función inner , pero para el mundo exterior inner será oculto.

La forma de crear métodos estáticos de un objeto es simple:

function f() {} 

f.staticVar = 5; 
f.staticFn = function() {}; 
// or 
f.prototype.staticFn = function() {}; 

Aquí el objeto función f sólo tendrá una staticFn que tiene acceso a variables estáticas, pero nada de los casos.

Tenga en cuenta que la versión prototype se heredará, mientras que la primera no se heredará.

Así que puede hacer un método privado que no está accediendo a nada desde las instancias, o crea un método estático al que no intenta acceder desde el exterior.

Answer 4

Los objetos pueden ser producidos por constructores, que son funciones que inicializan objetos. Los constructores proporcionan las características que proporcionan las clases en otros idiomas, incluidas las variables y los métodos estáticos.

leer todos los detalles en http://www.crockford.com/javascript/private.html

Answer 5

Puede hacerlo de esta manera:

var obj = new function() { 
    var method1 = function() { // private } 
    this.method2 = function() { // public } 
} 

obj.method1(); // not possible 
obj.method2(); // possible 

Tenga en cuenta que también utilizo un constructor anónimo. Esto es algo así como el patrón de Singleton.

Answer 6

Quizás desee un objeto proxy que solo contenga los métodos públicos, p. Ej.

var obj = (function() { 
    var obj = { 
    method1: function(){ 
     alert("method1"); 
    }, 
    method2: function(){ 
     alert("method2..."); 
     obj.method1(); 
    } 
    } 
    return { 
    method2: function() { return obj.method2.apply(obj, arguments) } 
    } 
})() 

// you could only call this function 
obj.method2(); 
// this function inaccessible 
obj.method1(); 

No veo el punto de los métodos privados en javascript. Si no quiere que las personas llamen a un método, no lo anuncie. Los métodos privados también hacen que la depuración también sea un poco más difícil.