了解javascript的全局命名空间和闭包 [英] understanding the javascript global namespace and closures

问题描述

1. p>是否有一个GOD（即一个父）对象，所有对象（因为除了基元之外的所有东西都是对象）回答，如果是的话，那个对象是窗口？




2. 为什么在全局级别上有vars / function是不好的？




3. vars /函数在全局范围，然后将闭包是避免这种最好的方法？例如：

     function parent（）{
    var x ='some value'; // this var will be considered全局到所有子函数，但不在真正的全局命名空间
    function child1（）{
    x.someMethod（）
   } 
    function child2（）{
   x * something ; 
   } 
    function child3（）{
    x + = something; 
    child2（）
    child1（）
   } 
    child3（）
   } 
    parent（）
     

解决方案

1. 
   

   是否有上帝（即父级）对象？

   
   

   是的。更技术上，这是所有这些原语都是成员的全局对象;只是发生在浏览器中，窗口对象是全局对象

   。

    > window.String === String; 
    true 
     




2. 
   

   为什么

   
   

   因为如果你添加了很多第三方库/脚本，他们都共享相同的全局对象，有名称冲突的机会。这是所有使用 $ 作为别名（jQuery，Prototype等）的库的真实生活问题。




3. 
   

   如果在全局范围内有vars / functions是一个坏主意，那么闭包是避免这种情况的最好方法吗？

   
   

   x 不应视为全局。它是通过在 parent（）函数中声明子函数形成的闭包的一部分。您的代码段的问题部分是 parent（）是全局的;如果一些其他代码重新声明 parent（）会发生什么？这将更好：

    （function（）{
    
    function parent（）{
    var x ='some value'; 
    function child1（）{
    x.someMethod（）
   } 
    function child2（）{
   x * something; 
   } 
    child3（）{
    x + = something; 
    child2（）
    child1（）
   } 
    child3 } 
    parent（）
    
   }（））; 
     

   事实 x 功能不坏;你应该自己写这些函数，所以你应该知道存在 x 。请记住，如果您在 var 的子函数中重新声明 x code>

b

I'm trying to improve my understanding of the global namespace in javascript and I'm curious about a few things:

1. is there a "GOD" (i.e. a parent) object that all objects (since all things except primitives are objects) to answer to and if so would that object be "window" ?

2. why is it bad idea to have vars/functions on a global level?

3. if it is really a bad idea to have vars/functions in global scope then would closures be the best way to avoid this? example:

   function parent(){
       var x = 'some value';//this var would be considered global to all children functions but not in the true global namespace
       function child1(){
           x.someMethod()
       } 
       function child2(){
           x*something;
       }
       function child3(){
           x+=something;
           child2()
           child1()
       }
       child3()
   }
   parent()
   

解决方案

1. Is there a god (i.e. a parent) object?

   Yes. More technically, it's the global object that all these primitives are members of; it just happens that in the browser, the window object is the global object.

   > window.String === String;
   true
   

2. Why is it bad idea to have vars/functions on a global level?

   Because if you're adding lots of 3rd party libraries/ scripts, they all share the same global object, there's the chance of name collisions. This is a real life problem with all the libraries which use $ as an alias (jQuery, Prototype and more).

3. If it is really a bad idea to have vars/functions in global scope then would closures be the best way to avoid this?

   x shouldn't be considered global. It's part of the closure formed by declaring the child functions inside the parent() function. The problem part of your snippet is that parent() is global; what happens if some other code re-declared parent()? This would be better:

   (function () {
   
   function parent(){
       var x = 'some value';
       function child1(){
           x.someMethod()
       } 
       function child2(){
           x*something;
       }
       function child3(){
           x+=something;
           child2()
           child1()
       }
       child3()
   }
   parent()
   
   }());
   

   The fact x is accessible within the child functions isn't bad; you should have written those functions yourself, so you should be aware of the existence of x. Bear in mind that if you re-declare x within those child functions with var, you won't affect the x in parent().

这篇关于了解javascript的全局命名空间和闭包的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！