javascript中的私有静态函数

如何创建不能从外部调用的函数

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

---

<>你可能想考虑使用。这是一个单例模式，方法不是真正静态的，但它可能是您所寻找的：

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

---

你可以使用一个闭包，类似于

var construct = function() {

   var obj = {};

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

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

   return obj;
}

obj = construct();

然后：

---

obj.method2

可访问，但

obj.method1

不存在供公众使用。只能使用类的成员函数访问它。

简单的答案是，不能同时执行这两个操作。您可以创建

“private”

方法或

“static”

方法，但不能像在其他语言中那样创建私有静态函数

模拟隐私的方法是：

这里由于闭包，每次调用

f

时都会创建

内部

函数，公共函数可以访问此

内部

函数，但对于外部世界，

内部

将被隐藏

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

function f() {}

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

这里，函数对象

f

只有一个

staticFn

，可以访问静态变量，但不能从实例中访问

请注意，

原型

版本将被继承，而第一个版本不会

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

对象可以由构造函数生成，构造函数是初始化对象的函数。构造函数提供类在其他语言中提供的特性，包括静态变量和方法

---

请在

上阅读所有相关内容，您可以这样做：

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

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

---

注意，我还使用匿名构造函数。这有点类似于单例模式

也许您希望代理对象只包含公共方法，例如

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中私有方法的意义。如果你不希望人们调用某个方法，那么就不要宣传它。私有方法也会使调试变得更加困难

这才是真正应该做的

var MyClass = new(function() {
    var privateStaticVariable = '';

    function privateStaticMethod() {

    }

    function construct() {
        var self = this;
        this.publicMethod = function() {};

        function privateMethod() {
            //maybe lest use our private static method
            privateStaticMethod();
        }
    }
    construct.publicStaticVariable = '';
    construct.publicStaticMethod = function() {};
    return construct;
})();

Now lets use it:

    var myClass = new MyClass();.....
MyClass.publicStaticMethod();
MyClass.publicStaticVariable = 'sfdsdf';
myClass.publicMethod();

---

…使用

类
。尽管有些功能仍然没有按要求提供


const instance=new（类Alpha{
静态#私有_静态_方法（）{
console.info（“我是私有的和静态的。”）；
}
静态公共\静态\方法（）{
Alpha.#private_static_method（）；
console.info（“我是公共的和静态的。”）；
}
#私有非静态方法（）{
console.info（“我是私有的、非静态的。”）；
}
公共非静态方法（）{
这是.#private_nonstatic_method（）；
console.info（“我是公共的，非静态的。”）；
}
});
instance.constructor.public_static_method（）；
//instance.constructor.#private_static_method（）；//不可能的
instance.public_nonstatic_method（）；
//实例.#private_nonstatic_method（）；//不可能
myPrivateMethod不是“静态”函数。你错过了标题。我不相信雅虎对模块模式有任何权利；）@新月号：我也不知道，但大家似乎都这么叫它。。。也许我应该说“模块模式，也就是Yahoo模块模式或YUI模块模式”：）我相信这个模式起源于YahooYUI团队的Eric Miraglia在一篇文章中提到：你想要静态函数还是静态方法？你希望它是静态的吗？（示例未阐明）静态方法和函数之间的区别是什么（顺便说一句，很抱歉使用这两个词）我想问题是javascript是否有静态方法
f.prototype.staticFn
实际上只是prototype对象的公共实例成员。它只是静态的，因为作为不同对象实例的成员，它无权访问此实例的私有成员。您也可以使用私有方法来实现这一点——只需给原型实例一个私有方法——这是没有帮助的，因为子实例无法访问该方法。简而言之，javascript中没有静态方法。
var MyClass = new(function() {
    var privateStaticVariable = '';

    function privateStaticMethod() {

    }

    function construct() {
        var self = this;
        this.publicMethod = function() {};

        function privateMethod() {
            //maybe lest use our private static method
            privateStaticMethod();
        }
    }
    construct.publicStaticVariable = '';
    construct.publicStaticMethod = function() {};
    return construct;
})();

Now lets use it:

    var myClass = new MyClass();.....
MyClass.publicStaticMethod();
MyClass.publicStaticVariable = 'sfdsdf';
myClass.publicMethod();