Javascript 类、编译器性能和新 Klass(） 上的内存分配

EDIT:
========================================================
Please see revision 13 of this test for answers: 
http://jsperf.com/closure-prototype-static-performance/
========================================================

我通常更喜欢这样声明我的klasses，因为我不是对象字面方式的忠实粉丝：

第一种方式：私人范围界定

    function Employees() {
            var persons = []; // [Person, Person]
            this.isEmployed = function(_firstName, _lastName) {
                    for ( var i = 0; i < persons.length ; i++ ) {
                            if ( persons[i].equals(_firstName, _lastName) ) {
                                    return true;
                            }
                    }
                    return false;
            }
    }
    function Person(_firstName, _lastName) {
            this.equals = function(firstName, lastName) {
                    return _firstName == firstName && _lastName == lastName;
            }
    }

第二种方式：原型

另一种方法是使用原型，但这样你就无法访问"私有"属性，例如 var person = [] 和 Person(...( 中的参数，但人们可能能够接受将它们公开，尽管对于人来说，将引入两个新属性：

    function Employees() {
            this.persons = []; // [Person, Person]
    }
    Employees.prototype.isEmployed = function(_firstName, _lastName) {
            for ( var i = 0; i < this.persons.length ; i++ ) {
                    if ( this.persons[i].equals(_firstName, _lastName) ) {
                            return true;
                    }
            }
            return false;
    };
    function Person(_firstName, _lastName) {
            this.firstName = _firstName;       // Two new properties. Are these or the function declared more expensive?
            this.lastName  = _lastName;
    }
    Person.prototype.equals = function(firstName, lastName) {
            return this.firstName == firstName && this.lastName == lastName;
    };

第三种方式：静态方法

另一种选择是像原型一样做，而是在"静态"之外制作方法：

    function Employees() {
            this.persons = []; // [Person, Person]
    }
    function isEmployed(employee, _firstName, _lastName) {
            for ( var i = 0; i < employee.persons.length ; i++ ) {
                    if ( equals(employee.persons[i], _firstName, _lastName) ) {
                            return true;
                    }
            }
            return false;
    }
    function Person(_firstName, _lastName) {
            this.firstName = _firstName;       // Two new properties. Are these or the function declared more expensive?
            this.lastName  = _lastName;
    }
    function equals(person, firstName, lastName) {
            return person.firstName == firstName && person.lastName == lastName;
    }

问题：

1.您认为哪种方法最适合性能，内存和CPU功率，为什么或何时应该尝试避免或遵循另一种方法？

阿拉伯数字。从这个角度来看，最后一个"静态"范围界定的例子是否比原型方法更好？

3.当涉及到第一种方式时，这是我更喜欢的方式，因为它更整洁，允许"私有"范围，并且所有代码都非常适合，编译器是否可能为您执行原型方法，或者是否为您所做的每个新人一遍又一遍地声明这些函数？

当我做很多new((并且涉及很多方法时，我尽量避免使用第一种方法，然后我通常会采用静态方法，尽管我想知道我是否有任何真正好的reaoson来做到这一点？

4.我注意到我的示例不包含">私有"函数，那么编译器如何处理它们？

例：

    function Person(_firstName, _lastName) {
            function privateFunction() {
                    // How does the compile treat private functions. Are they also created once per new Person() ? Cheap or expensive?
            }
    }