自执行匿名函数与原型

在Javascript中，有几种在JavaScript中创建和管理类/命名空间的突出技术。

我很好奇哪种情况需要使用一种技术而不是另一种技术。我想选一个并坚持前进。

我编写了由多个团队维护和共享的企业代码，并且我想知道编写可维护的javascript时的最佳实践是什么？

我倾向于使用自执行匿名功能，但是我很好奇社区对这些技术的投票。

原型：

function obj()
{
}

obj.prototype.test = function() { alert('Hello?'); };
var obj2 = new obj();
obj2.test();

自闭式匿名函数：

//Self-Executing Anonymous Function 
(function( skillet, $, undefined ) {
    //Private Property
    var isHot = true;

    //Public Property
    skillet.ingredient = "Bacon Strips";

    //Public Method
    skillet.fry = function() {
        var oliveOil;

        addItem( "\t\n Butter \n\t" );
        addItem( oliveOil );
        console.log( "Frying " + skillet.ingredient );
    };

    //Private Method
    function addItem( item ) {
        if ( item !== undefined ) {
            console.log( "Adding " + $.trim(item) );
        }
    }     
}( window.skillet = window.skillet || {}, jQuery ));   
//Public Properties      
console.log( skillet.ingredient ); //Bacon Strips  

//Public Methods 
skillet.fry(); //Adding Butter & Fraying Bacon Strips 

//Adding a Public Property 
skillet.quantity = "12"; console.log( skillet.quantity ); //12   

//Adding New Functionality to the Skillet 
(function( skillet, $, undefined ) {
    //Private Property
    var amountOfGrease = "1 Cup";

    //Public Method
    skillet.toString = function() {
        console.log( skillet.quantity + " " + 
                     skillet.ingredient + " & " + 
                     amountOfGrease + " of Grease" );
        console.log( isHot ? "Hot" : "Cold" );
     };     

}( window.skillet = window.skillet || {}, jQuery ));
//end of skillet definition


try {
    //12 Bacon Strips & 1 Cup of Grease
    skillet.toString(); //Throws Exception 
} catch( e ) {
    console.log( e.message ); //isHot is not defined
}

我觉得我应该提到自执行匿名函数是jQuery团队使用的模式。

更新 当我问这个问题时，我并没有真正理解我想要理解的重要性。真正的现实问题是是否使用new来创建对象的实例或使用不需要构造函数/无需使用new关键字的模式。

我添加了自己的答案，因为我认为我们应该使用不使用new关键字的模式。

有关更多信息，请参见我的答案。

自执行匿名函数用于自动执行脚本，而无需陷入外部事件（例如window.onload）。

在此示例中，它用于形成经典的模块模式，其主要目的是将命名空间引入全局环境，并为未“导出”或未附加到命名空间的任何内部属性提供封装。

另一方面，修改对象原型用于建立继承（或扩展本机）。此模式用于产生具有常用方法或属性的1：n对象。

您不应优先选择一种模式，因为它们执行不同的任务。就命名空间而言，自执行功能是一个适当的选择。

这是我刚开始使用的模式（直到昨天一直在使用它的变体）：

function MyClass() {
    // attributes
    var privateVar = null;

    // function implementations
    function myPublicFunction() {
    }

    function myPrivateFunction() {
    }

    // public declarations
    this.myPublicFunction = myPublicFunction;
}

MyClass.prototype = new ParentClass(); // if required

关于此的一些想法：

1. 您不应(anonymous)在调试器堆栈跟踪中获得任何跟踪，因为所有内容都已命名（没有匿名函数）。
2. 这是我见过的最干净的模式
3. 您可以轻松地将公开的API进行分组，而无需将其实现与声明耦合在一起（这意味着某人可以轻松浏览您的公共类接口而无需滚动）

我唯一prototype真正使用过的时间就是定义继承。

我使用原型是因为它们更干净并且遵循标准的继承模式。自我调用功能非常适合浏览器开发或您不知道代码在何处执行的情况，但是这只是噪音。

例：

var me;

function MyObject () {
    this.name = "Something";
}

MyObject.prototype.speak = function speak () {
    return "Hello, my name is " + this.name;
};

me = new MyObject();
me.name = "Joshua";
alert(me.speak());

我会使用自我执行功能，但有一点区别：

MyClass = (function() {
     var methodOne = function () {};
     var methodTwo = function () {};
     var privateProperty = "private";
     var publicProperty = "public";

     return function MyClass() {
         this.methodOne = methodOne;
         this.methodTwo = methodTwo;
         this.publicProperty = publicProperty;
     };
})();

如果发现这种方法更简洁，那么当我将返回的全局变量与任何输入参数（例如jQuery）分开时（您编写它的方式就等同于返回void并在C＃中使用ref参数，我发现有点不对劲，或者将指针传递给指针，然后在C ++中将其重新分配）。如果我随后将附加的方法或属性附加到类上，则将使用原型继承（例如jQuery的$ .extend方法，但是很容易滚动自己的extend（））：

var additionalClassMethods = (function () {
    var additionalMethod = function () { alert('Test Method'); };
    return { additionalMethod: additionalMethod };
})();

$.extend(MyClass.prototype, additionalClassMethods);

var m = new MyClass();
m.additionalMethod(); // Pops out "Test Method"

这样，您就可以清楚地区分添加的方法和原始方法。

现场例子

(function _anonymouswrapper(undefined) {

    var Skillet = {
        constructor: function (options) {
            options && extend(this, options);
            return this; 
        },
        ingredient: "Bacon Strips",
        _isHot: true,
        fry: function fry(oliveOil) {
            this._addItem("\t\n Butter \n\t");
            this._addItem(oliveOil);
            this._addItem(this.ingredient);
            console.log("Frying " + this.ingredient);
        },
        _addItem: function addItem(item) {
            console.log("Adding " + item.toString().trim());
        }
    };

    var skillet = Object.create(Skillet).constructor();

    console.log(skillet.ingredient);
    skillet.fry("olive oil");

    var PrintableSkillet = extend(Object.create(Skillet), {
        constructor: function constructor(options) {
            options && extend(this, options);
            return this;
        },
        _amountOfGrease: "1 Cup",
        quantity: 12,
        toString: function toString() {
            console.log(this.quantity + " " +
                        this.ingredient + " & " +
                        this._amountOfGrease + " of Grease");
            console.log(this._isHot ? "Hot" : "Cold");
        }
    });

    var skillet = Object.create(PrintableSkillet).constructor();

    skillet.toString();

    function extend(target, source) {
        Object.getOwnPropertyNames(source).forEach(function (name) {
            var pd = Object.getOwnPropertyDescriptor(source, name);
            Object.defineProperty(target, name, pd);
        });
        return target;
    }
}());

您可以使用IIFE在代码周围模拟“模块作用域”。然后，您可以像平常一样使用对象。

不要使用闭包“模拟”私有状态，因为这样做会占用大量内存。

如果您正在编写企业应用程序，并且希望将内存使用量保持在1GB以下，请避免不必要地使用闭包来存储状态。

更新 ，现在我对javascript有更好的理解，并觉得我可以正确解决这个问题。我认为这是措辞不佳，但非常重要的javascript主题。

如果您避免在函数外部使用此功能，则自执行匿名功能模式不是要求使用new关键字的模式。我同意使用新技术是一种旧技术的想法，我们应该努力使用避免使用新技术的模式。

自执行匿名功能满足此条件。

这个问题的答案是主观的，因为javascript中有太多的编码样式。但是，根据我的研究和经验，我建议选择使用自执行匿名函数来定义您的API，并尽可能避免使用new。

这就是我将如何IIFE SelfExecutingFunction扩展Myclasswith的方法Myclass.anotherFunction()；

MyClass = (function() {
     var methodOne = function () {};
     var methodTwo = function () {};
     var privateProperty = "private";
     var publicProperty = "public";

    //Returning the anonymous object {} all the methods and properties are reflected in Myclass constructor that you want public those no included became hidden through closure; 
     return {
         methodOne = methodOne;
         methodTwo = methodTwo;
         publicProperty = publicProperty;
     };
})();

@@@@@@@@@@@@@@@@@@@@@@@@
//then define another IIFE SEF to add var function=anothermethod(){};
(function(obj){
return obj.anotherfunction=function(){console.log("Added to Myclass.anotherfunction");};
})(Myclass);

//the last bit : (function(obj){})(Myclass); obj === Myclass obj is an alias to pass the Myclass to IIFE

var myclass = new Myclass();
myclass.anotherfunction(); //"Added to Myclass.anotherfunction"