Question

假设我需要声明一些私有静态成员，以便在某些公共静态方法中使用它。。

// ***** Variant I *****
function supports() {
    var impl = document.implementation; // private, non-static
    this.SVG = function () {            // public, non-static
      return impl.hasFeature("http://www.w3.org/TR/SVG11/feature#Image", "1.1");
    };
}

// ***** Variant II *****
function supports() { }
supports.prototype.impl = document.implementation; // public, non-static
supports.SVG = function () {                       // public, static
  return impl.hasFeature("http://www.w3.org/TR/SVG11/feature#Image", "1.1");
};

我知道JavaScript中存在一些“静态”问题。 OOP的概念，所以我的问题是：

我是否可以声明 公共静态 方法＆＃34;声明正文＆＃34;对象＆＃39; （比如＆＃34;变体I＆＃34;上面）？

Answer 1

在你的Variant II中，所谓私有和静态的函数既不是私有的，也不是静态的。

你是正确的，定义类的私有静态成员是非常困难的，但如果你利用JavaScript的范围，它是可能的。

var Person = (function(){

    var privateStaticProperty = true;

    function privateStatic() {
        return privateStaticProperty;
    }

    function Person(){

        // class declarations
    }

    Person.prototype.example = function() {
        return privateStatic();
    }

    return Person;
}());

var p = new Person();
console.log(p.example());

但请注意，如果将原型扩展到闭包之外，那么所谓的私有静态成员将无法使用。

Answer 2

在JavaScript中，没有术语或关键字静态，但我们可以将这些数据直接放入函数对象中（就像在任何其他对象中一样）。

静态方法

静态方法与变量一样，附加到函数中。它们主要用于对象：

function Animal(name) {
  arguments.callee.count = ++arguments.callee.count || 1 

  this.name = name
}

Animal.showCount = function() {
  alert( Animal.count )
}

var mouse = new Animal("Mouse")
var elephant = new Animal("elephant")

Animal.showCount()  // 2

Answer 3

JavaScript中没有私有，静态或公共。只有本地和全球，范围内和范围外。使用IIFE捕获变量并返回闭包;这应该与静态方法等效。

var supports = (function supportsWrapper() {
    var impl = document.implementation; // "static"-ish.
    return function supports() {
      this.SVG = function () {
        return impl.hasFeature("http://www.w3.org/TR/SVG11/feature#Image", "1.1");
      };
    }
})();

impl只会被初始化一次，并且只能由supports读取，但会在调用它之间保持不变。

Answer 4

我在分析一些答案后看到的唯一解决方案是：

var Person = (function () {

    var _privateStatic = 'private static member';
    function privateStatic() {
        return _privateStatic + ' + private-s-function';
    }

    function Person() {

        this.publicNonStatic = 'public, non-static member';
        this.publicFunction = function () { 
            return this.publicNonStatic + '+ public non-static-function'; 
        }

        var _privateNonStatic = 'private, non-static member';
        function privateNonStatic() {
            return _privateNonStatic + " + private-ns-function"
        }

        this.publicStatic = Person.publicStatic = 'public static member';
        this.publicStaticFunction = Person.publicStaticFunction = function () {
            return Person.publicStatic + ' + public static function';
        }        

        // Accessible internal 
        var test = _privateNonStatic;
        test = _privateStatic;
        test = privateStatic();
        test = privateNonStatic();

        // other class declarations
    }
    return Person;
}());

// Accessible external members: 
var p = new Person();
console.log(p.publicFunction());
console.log(p.publicNonStatic);
console.log(p.publicStatic);
console.log(p.publicStaticFunction());
console.log(Person.publicStatic); 
console.log(Person.publicStaticFunction());

PS。

但我注意到publicStaticFunction（）仅在new Person()声明后才可访问...因此，之前它们不可用：

// Accessible external members: console.log(Person.publicStatic); // NO WAY console.log(Person.publicStaticFunction()); // NO WAY var p = new Person(); // lazy declaration console.log(Person.publicStatic); // IS OK! console.log(Person.publicStaticFunction()); // IS OK!

，所以我认为没有办法在函数Person体内实现它，只能在包含Person的匿名函数内...

所以最初的SVG样本应该是这样的：

var supports = (function(){ function supports() { this.SVG = supports.SVG; } supports.SVG = function () { return document.implementation.hasFeature("http://shortened", "1.1"); }; return supports; }()); // usage of public, static method if (supports.SVG()) {return 'supports SVG!';}

宣布公开＆＃34;静态＆＃34; JavaScript类中的函数

4 个答案: