javascript中的私有静态函数

Question

如何创建无法从外部调用的函数？

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

你可能要考虑使用Yahoo Module Pattern。这是一个单例模式和方法是不是真的静态的，但它可能是你在找什么：

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()); 
     } 
    }; 
})(); 

您可以定义myPrivateVar和myPrivateMethod定义您的私有成员，你的公共成员，其中myPublicVar和定义了myPublicMethod。

你可以简单地访问公共的方法和属性如下：

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

Answer 2

可以使用封闭，沿东西....的

var construct = function() { 

    var obj = {}; 

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

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

    return obj; 
} 

obj = construct(); 

然后行：

obj.method2可以访问，但obj.method1不存在供公众使用。它只能使用该类的成员函数进行访问。

Answer 3

简单的答案是你不能同时做两个。您可以创建"private"方法或"static"方法，但不能像在其他语言中那样创建私有静态函数。

可以模拟隐私的方式是关闭：

function f() { 

    function inner(){} 

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

这里，因为关闭中，inner功能将被创建每次调用f时间，而公共职能可以存取权限此inner功能，但对于外部世界inner将隐藏。

创建一个对象的静态方法的方法很简单：

function f() {} 

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

这里的函数对象f将只能从实例一个staticFn它可以访问静态变量，但一无所获。

请注意，prototype版本将被继承，而第一个不会。

因此，您要么创建一个不访问实例中任何内容的私有方法，要么创建一个静态方法，而您并不试图从外部访问它。

Answer 4

目的可以通过构造，这是其初始化对象的功能来生产。构造函数提供类以其他语言提供的功能，包括静态变量和方法。

阅读所有关于它在http://www.crockford.com/javascript/private.html

Answer 5

你可以这样说：

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

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

注意，我还使用匿名构造函数。这与Singleton模式类似。

Answer 6

也许你想要一个只包含公共方法的代理对象，例如

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(); 

我在javascript中看不到私有方法的要点。如果你不想让人们调用一个方法，那么不要做广告。私有方法也使调试更加困难。