在 JavaScript 类中声明一个公共的“静态”函数

Question

假设我需要声明一些 private static 成员以在一些 public static 方法中使用它。 .

// ***** 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");
};

我知道使用“静态”OOP 概念的 JavaScript 存在一些困难，所以我的问题是：

我可以在“对象”的“声明主体”中声明 public static 方法inside（如上面的“变体 I”） )?

Answer 1

在您的变体 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 中，没有术语或关键字 static，但我们可以将这些数据直接放入函数对象中（就像在任何其他对象中一样）。

静态方法

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

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!';}