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

简单的答案是你不能同时做到。您可以创建"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 3

你可以使用一个封闭的东西......

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 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中看到私有方法的意义。如果您不希望人们调用方法，则不要做广告。私有方法也使调试变得更难。

Answer 7

这才是真正应该做的。

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

.....

Answer 8

使用class。尽管某些功能仍未以it’s at Stage 3的形式提供。

const instance = new (class Alpha {
	static #private_static_method() {
		console.info("I am private and static.");
	}
	static public_static_method() {
		Alpha.#private_static_method();
		console.info("I am public and static.");
	}
	#private_nonstatic_method() {
		console.info("I am private and non-static.");
	}
	public_nonstatic_method() {
		this.#private_nonstatic_method();
		console.info("I am public and non-static.");
	}
});

instance.constructor.public_static_method();
// instance.constructor.#private_static_method(); // impossible
instance.public_nonstatic_method();
// instance.#private_nonstatic_method(); // impossible

javascript中的私有静态函数

8 个答案: