在对象中存储函数-糟糕的实践？

在对象中存储函数而不是仅仅定义它们(因此是全局的)被认为是糟糕的编码实践吗？

考虑一下:

1.

Foo = {
bar: function() {
alert("baz");
}
}

Foo.bar();

对。

2.

function bar() {
alert("baz");
}

bar();

当然，对于第二个示例，代码可能会稍微少一些，但是当您开始获得大量函数时，就会变得混乱。 我发现使用 Game.update()而不是 updateGame ()或类似的方法更简单、更方便。当更深入的时候，比如 Game.notify.admin(id)等等，它会给你更漂亮的代码。

在对象中存储函数有什么缺点吗？

73008 次浏览
小开
最佳答案

The first approach is preferred. This way you are explicitly defining the scope of your functions instead of polluting the global scope. There are no downsides of using the first approach. Only upsides :-)

Conclusion: always use the first approach to define functions. The second is like javascript in the 90s, let's leave it rest in peace back in the past and use proper scoping.

小开

In this specific case go with the first one. But if you Foo object gets really complex you might want to use another approach that will give you the opportunity to use a constructor. And also the first approach sometimes is not the best when it comes to the function's scope:

function Foo(appName){
this.name = appName;
}


Foo.prototype.Bar = function(){
alert(this.name)
}


var a = new Foo("baz");
a.Bar();
小开

There is no magic with namespace objects, nor will you necessarily have any issues if you use lots of global variables. The main reason to use "namespace" objects is to reduce the potential for duplicate global variable names. A second reason is to group similar functions together for convenience, e.g:

// Object example (suggested best practice):
// DOM functions are under myLib.dom
myLib.dom.someDOMFunction0;
myLib.dom.someDOMFunction1;


// Utility functions are under myLib.util
myLib.util.someUtilityFunction0;
myLib.util.someUtilityFunction1;

Note that the above has practically the same chance of duplicates as similarly global variables:

// Global variable example:
myLib_dom_someDOMFunction0;
myLib_dom_someDOMFunction1;


myLib_util_someUtilityFunction0;
myLib_util_someUtilityFunction1;

Of course the former is generally preferred because it seen as easier to work with. I'm not advocating that you adopt the second approach (I use the first), just pointing out that while there is an issue with creating lots of global variables, so–called "global namespace pollution" is greatly overrated as a hazard.


提交答案