声明一个JavaScript类

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概念有一些困难，所以我的问题是：

我可以声明公共静态方法里面“对象”的“声明主体”（如上面的“变体I”）？

Answer 1

我分析了一些答案后看到的唯一的解决办法是这样的一个：

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()声明becames入店......所以，它他们不可供选择：

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

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

在你变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 4

在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，但对它的调用之间将持续存在。