Question

我有一个.js文件，我正在初始化两个使用的参数在一个单独的功能：

var submyvar1;
var submyvar2;

function init(myvar1 , myvar2){
    submyvar1= myvar1;
    submyvar2= myvar2;
}

function (){
    //subvar1 & subvar 2 used here
}

宣布像这样的全局变量是一种不好的做法吗？

如果是，替代方法是什么，将整个.js文件包装在一个对象中？

Answer 1

至少它不是一个好的练习，你可以使用即时调用的函数表达式：

(function() {
    var x;
    var y;

    window.init = function(xValue, yValue) {
        x = xValue;
        y = yValue;
    }

    window.doWhateverYouWant = function() {
        console.log(x + y);
    }
}());

您可以使用此模式，除非您需要访问此.js文件之外的全局变量，当需要在.js文件或<script>元素之间进行交叉访问时，全局变量为一个简单的解决方案（虽然您可以使用AMD或其他方式）。

Answer 2

我决定使用一个揭示模块模式，如下所述：关于使用'揭示模块模式'的可能实现的好文章：http://enterprisejquery.com/2010/10/how-good-c-habits-can-encourage-bad-javascript-habits-part-1/

它与接受的答案非常相似。

以下是从enterprisejquery上面粘贴的模式：

We looked at the Self-Executing Anonymous Function earlier as a pattern you could use to keep all your code private. As it turns out, you can actually modify the pattern somewhat so that you can achieve the same benefits of the Revealing Module Pattern. Not only can we achieve public and private properties and methods, but we can also provide an easy way to extend the namespace while keeping the content protected from the global namespace. In addition, the following pattern can protect the $ from conflicting with other JavaScript libraries and also protect undefined from being redefined.

Take a look at the following example, and we will walk through the code explaining the key changes to the pattern.


//Self-Executing Anonymous Func: Part 2 (Public & Private)
(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 ));

try {
    //12 Bacon Strips & 1 Cup of Grease
    skillet.toString(); //Throws Exception
} catch( e ) {
    console.log( e.message ); //isHot is not defined
}
You can execute and modify the above code from jsFiddle.

First, since we have a Self-Executing Anonymous Function, we can actually provide some parameters to pass to it when it executes. In this case we are passing 2 arguments to the anonymous function.

The first argument looks quite strange. What is window.skillet = window.skillet || {} doing? The code checks to see if skillet exists in the global namespace (window). If it does not exist, then window.skillet is assigned an empty object literal. Using this approach we can build a library across JavaScript files. If another script uses the same technique, then it will pass in the existing instance and append logic to it. Inside the Anonymous Function, if we want something to be public, then we append it to the skillet object. Any other properties or methods will be considered private.

The second argument passed in jQuery. The benefit of this is that the named parameter is referenced as $, which allows us to refer to jQuery as $ within the Anonymous Function without having to worry that it will conflict with the $ declared in other JavaScript libraries. This is a common practice that you will most likely run across when looking at well written jQuery code.

You might notice a 3rd parameter to the Anonymous Function called undefined. Why did we add that parameter and why didn’t we pass an argument to it? In JavaScript, you can unfortunately redefine what undefined means. Imagine that some code somewhere deep in one of your 3rd party libraries redefines undefined to something strange like true. If anywhere in your code you test against undefined, then you code will most likely not behave like you intended. In JavaScript, if you have a parameter that doesn’t have a matching argument, then it’s value is set as undefined. By using this trick, it can save us from the bad code someone wrote to redefine undefined.

Pros

Gives you the ability to have public and private properties and methods
The code inside doesn’t use the Object Literal notation
Keeps undefined’s value as undefined in case someone overrode the value
Allows you to use $ inside your code without worrying about clashing with other libraries
Allows your library to grow across files using the “window.namespace = window.namespace || {}” technique
A common pattern that you will see in many libraries, widgets, and plugins
Cons

Slightly more complicated pattern, but not overly difficult to understand
If you are interested in digging deeper into some of the patterns I mentioned above then I encourage you to check out Klaus Komenda’s post entitled JavaScript Programming Patterns. The article provides an insightful view of how JavaScript patterns have changed over the years.

Answer 3

您应尽可能避免使用它以防止混乱全局命名空间。可能会有一些你想要公开的代码，所以在这种情况下它很好。例如，jQuery显然必须使jQuery和$变量成为全局变量（它通过使它们成为window的属性来实现。

为避免这种情况，您可以将代码包含在一个带括号的函数中：

var mySingleGlobalVar = (function () {
    var submyvar1;
    var submyvar2;

    function init(myvar1 , myvar2){
        submyvar1= myvar1;
        submyvar2= myvar2;
    }

    function (){
        //subvar1 & subvar 2 used here
    }

    return init;
}());

这是一个立即执行的功能。在这个例子中，我已经将返回值（init函数）分配给全局var，这是您的脚本将创建的唯一全局变量（只要您使用var正确声明它们）。 / p>

Answer 4

在JavaScript: The Good Parts（也总结为here）中，建议：

全球变量削弱了计划的弹性，应该如此避免。最小化全局变量使用的一种方法是创建单个变量适用于您的应用程序的全局变量：
var MYAPP = {};
该变量随后成为您的应用程序的容器：
MYAPP.stooge = {
    "first-name": "Joe",
    "last-name": "Howard" };
通过将您的全球足迹减少到一个名称，您就显着了减少与其他应用程序交互不良的可能性，小部件或库。您的程序也变得更容易阅读因为很明显MYAPP.stooge指的是顶级结构

在a.js文件中声明全局变量是不好的做法吗？

4 个答案: