下面是小编帮大家整理的javascript 作用域、作用域链理解，本文共6篇，希望对大家的学习与工作有所帮助。本文原稿由网友“shouji88”提供。

篇1：javascript 作用域、作用域链理解

JavaScript作用域就是变量和函数的可访问范围，

1.变量作用域

在JavaScript中,变量作用域分为全局作用域和局部作用域。

全局作用域

任何地方都可以定义拥有全局作用域的变量

1.没有用var声明的变量（除去函数的参数）都具有全局作用域，成为全局变量，所以声明局部变量必须要用var

2.window的所有属性都具有全局作用域

3.最外层函数体外声明的变量也具有全局作用域

var globalScope=“globalScope”;

function checkScope{

var partScope=“part”;

scope=“scope”;

}

checkScope();

console.log(globalScope);//globalScope,全局变量

console.log(scope);    //scope，全局变量

console.log(partScope);//Uncaught ReferenceError: partScope is not defined，报错：没有定义partScope

局部作用域

1.函数体内用var声明的变量具有局部作用域，成为局部变量

2.函数的参数也具有局部作用域

var globalScope=“globalScope”;

function checkScope(x){

scope=“scope”; //变成了全局变量

var partScope=“part”;//在函数体内，声明局部变量一定要加var

var globalScope=“partScope”;

}

checkScope(12);

console.log(globalScope);//globalScope,在函数体内，局部变量的优先级高于全局变量

console.log(scope);//scope，全局变量 console.log(partScope);

console.log(partScope);// Uncaught ReferenceError: partScope is not defined，局部变量外面访问不到

console.log(x);//局部变量外面访问不到

总结：在函数体内局部变量的优先级高于同名的全局变量，声明局部变量必须用var

2.函数作用域

一些类C语言是块级作用域（block scope），每一个花括号是一个作用域，花括号内的代码对外是不可见的，

而

JavaScript是函数作用域（function scope），没有块级作用域。无论函数体内的变量在什么地方声明，对整个函数都是可见的，即JavaScript函数里声明的所有变量都被提前到函数体的顶部，只是提前变量声明，变量的赋值还是保留在原位置

函数作用域只能用函数来声明独立作用域，并不是每一个花括号都是一个独立作用域，例如：for循环并不能创建一个局部的作用域

for(var i=0;i<5;i++){

var scope='scope';

}

console.log(i) //5;i仍然存在，因为JavaScript是函数作用域而不是块级作用域

console.log(scope);//scope;scope仍然存在

function checkScope(){

console.log(funScope); // undefined,函数里声明的所有变量都被提前到函数体的顶部,所以funScope才会认为已经存在

var funScope=“funScope”;

}

checkScope();

3.作用域链

作用域链：JavaScript的变量都是对象的属性，而该对象可能又是其它对象的属性，而所有的对象都是全局对象的属性，所以这些对象的关系可以看作是一条链，

链头就是变量所处的对象，链尾就是全局对象

function checkScope(scope){

var funScope=“funScope”;

var s=scope;

}

在查找变量funScope的值时，会先查找当前对象，如果当前对象查不到就继续查找作用域链上面的下一个对象，如果作用域链上没有一个对象包含此属性，就抛出引用错误。

在不包含嵌套的函数体内，作用域链上有两个对象：

1.定义函数参数和局部变量的对象

2.全局对象

在包含嵌套的函数体内，作用域链上至少有三个对象

篇2：故障解析：DHCP作用域

下面我们主要讲解一下通过DHCP作用域来处理故障的问题，笔者所在学校有两个机房，机房A的计算机是指定IP地址，机房B的计算机采用DHCP服务自动获取IP地址。两个机房在同时使用并上网时，部分计算机经常出现故障（如上不了网、速度缓慢）。

原因分析

每次指定IP地址的机房A先开机时，该机房内的所有计算机都能正常上网；若采用自动获取（DHCP）IP地址的机房B先开机时，则会引发机房B与机房A内的计算机IP地址冲突，致使部分>计算机不能上网。于是，笔者决定在机房B的DHCP作用域中留出指定IP地址段，以避免IP地址冲突。

解决过程

在重新设置好DHCP作用域后，笔者并没有重新启动Windows Server（服务器系统），结果出现机房B里的所有计算机不能上网的新问题。开始以为是接入线路有故障，但用测试仪器检测正常；遂怀疑集线器硬件有问题，认为是由于硬件损坏引起的广播风暴导致的，更换集线器后故障依旧；再考虑是否有多余的线路构成了回路，使数据包不断发送和校验数据，从而导致不能上网，笔者马上去掉所有连接确保不会构成回路，只针对机房B配备一个集线器，问题还是存在；当笔者已经感到山穷水尽时，无意中重新启动服务器，问题立即得到解决，

总结

当指定IP地址和由DHCP获取IP地址发生冲突而导致部分计算机不能上网时，应当在DHCP作用域中预留出指定的IP地址段，避免IP地址重复；而在重新设置好DHCP作用域后，出现用DHCP自动获取IP地址的机房里的所有计算机不能上网，是由于Windows 2000 Server没有重新启动导致的，可看出在Windows 2000 Server中进行网络设置后不用重新启动即可生效是不可靠的；另外，使用逐步排除法也是解决类似问题的一个好方法。

篇3：Spring bean的作用域

下面通过一个例子来演示怎么自定义作用域并且分析框架中的代码自定义作用域是怎么实现，这个自定义scope的功能是把bean缓存到一个LRU缓存中，当bean被踢出缓存时触发析构回调

实现Scope接口，LRU缓存中最多只能放两个bean，被踢掉的bean会触犯析构回调，在removeEldestEntry方法中，析构回调保存在destructionCallback哈希表中：

public class LRUCacheScope implements Scope { private class BeanCache extends LinkedHashMap{ private static final long serialVersionUID = -887300667768355251L; @Override protected boolean removeEldestEntry(Entryeldest) { boolean flag = size >maxBeanNumber; if (flag) { executeDesCallback(eldest.getKey()); } return flag; } } private static final int DEFAULT_MAX_BEAN_NUMBER = 2; private MapbeanCache = Collections .synchronizedMap(new BeanCache()); private int maxBeanNumber; private MapdestructionCallback = new HashMap(); public LRUCacheScope() { this(DEFAULT_MAX_BEAN_NUMBER); } public LRUCacheScope(int maxBeanNumber) { super(); this.maxBeanNumber = maxBeanNumber; } @Override public Object get(String name, ObjectFactory<?>objectFactory) { Object bean = beanCache.get(name); if (bean == null) { bean = objectFactory.getObject(); beanCache.put(name, bean); } return bean; } @Override public Object remove(String name) { destructionCallback.remove(name); return beanCache.remove(name); } @Override public void registerDestructionCallback(String name, Runnable callback) { destructionCallback.put(name, callback); } @Override public Object resolveContextualObject(String key) { return null; } @Override public String getConversationId() { return null; } private void executeDesCallback(String beanName) { Runnable callBack = destructionCallback.get(beanName); if (callBack != null) { callBack.run(); } destructionCallback.remove(beanName); }}定义CustomScopeConfigurer注册Scope，并且定义其它的测试bean

JUnit测试代码

@Testpublic void test() { BeanFactory context = new ClassPathXmlApplicationContext( “spring/beans/scope/scope.xml”); ScopedBean bean1 = (ScopedBean) context.getBean(“scopedBean1”); ScopedBean bean11 = (ScopedBean) context.getBean(“scopedBean1”); assertEquals(bean1, bean11); ScopedBean bean2 = (ScopedBean) context.getBean(“scopedBean2”); ScopedBean bean3 = (ScopedBean) context.getBean(“scopedBean3”); bean11 = (ScopedBean) context.getBean(“scopedBean1”); assertNotEquals(bean1, bean11);}

执行测试代码发现代码执行通过，可以发现最后一次取出的scopedBean1和前面的scopedBean1已经不是一个实例了，查看控制台日志发现有如下信息：

22:28:48,738 DEBUG DefaultListableBeanFactory:432 - Creating instance of bean 'scopedBean1'22:28:48,738 DEBUG DefaultListableBeanFactory:460 - Finished creating instance of bean 'scopedBean1'22:28:48,738 DEBUG DefaultListableBeanFactory:432 - Creating instance of bean 'scopedBean2'22:28:48,738 DEBUG DefaultListableBeanFactory:460 - Finished creating instance of bean 'scopedBean2'22:28:48,738 DEBUG DefaultListableBeanFactory:432 - Creating instance of bean 'scopedBean3'22:28:48,738 DEBUG DefaultListableBeanFactory:460 - Finished creating instance of bean 'scopedBean3'22:28:48,738 DEBUG DisposableBeanAdapter:227 - Invoking destroy() on bean with name 'scopedBean1'destroy:spring.beans.scope.ScopedBean@18235ed22:28:48,738 DEBUG DefaultListableBeanFactory:432 - Creating instance of bean 'scopedBean1'22:28:48,738 DEBUG DefaultListableBeanFactory:460 - Finished creating instance of bean 'scopedBean1'22:28:48,738 DEBUG DisposableBeanAdapter:227 - Invoking destroy() on bean with name 'scopedBean2'destroy:spring.beans.scope.ScopedBean@1a28362从日志可以看出在创建完scopedBean3并且添加到缓存中之后scopedBean1被踢掉了并且触发了析构回调，我们ScopedBean实现了DisposableBean接口，它的destroy方法被调用了：

public class ScopedBean implements DisposableBean { @Override public void destroy() throws Exception { System.out.println(“destroy:” + this); }}

篇4：Spring bean的作用域

现在大致分析一下自定义作用域时如何实现的

首先看下CustomScopeConfigurer类，看下它的postProcessBeanFactory方法：

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { if (this.scopes != null) { for (Map.Entryentry : this.scopes.entrySet()) { String scopeKey = entry.getKey(); Object value = entry.getValue(); if (value instanceof Scope) { beanFactory.registerScope(scopeKey, (Scope) value); } else if (value instanceof Class) { Class scopeClass = (Class) value; Assert.isAssignable(Scope.class, scopeClass); beanFactory.registerScope(scopeKey, (Scope) BeanUtils.instantiateClass(scopeClass)); } else if (value instanceof String) { Class scopeClass = ClassUtils.resolveClassName((String) value, this.beanClassLoader); Assert.isAssignable(Scope.class, scopeClass); beanFactory.registerScope(scopeKey, (Scope) BeanUtils.instantiateClass(scopeClass)); } else { throw new IllegalArgumentException(“Mapped value [” + value + “] for scope key [” +scopeKey + “] is not an instance of required type [” + Scope.class.getName() +“] or a corresponding Class or String value indicating a Scope implementation”); } } }}在这个方法中把所有scope都注册到beanFactory中，来看看bean工厂的registerScope方法，在AbstractBeanFactory类中，在这个方法中把所有的作用域对象都存储到了scopes哈希表属性中，作用域名称作为哈希表的key：

public void registerScope(String scopeName, Scope scope) { Assert.notNull(scopeName, “Scope identifier must not be null”); Assert.notNull(scope, “Scope must not be null”); if (SCOPE_SINGLETON.equals(scopeName) || SCOPE_PROTOTYPE.equals(scopeName)) { throw new IllegalArgumentException(“Cannot replace existing scopes 'singleton' and 'prototype'”); } this.scopes.put(scopeName, scope);}接下来看看bean的获取方法，在AbstractBeanFactory的doGetBean方法中，看doGetBean方法的代码片段：

if (mbd.isSingleton()) { ... }else if (mbd.isPrototype()) { ... }else { String scopeName = mbd.getScope(); final Scope scope = this.scopes.get(scopeName); if (scope == null) { throw new IllegalStateException(“No Scope registered for scope '” + scopeName + “'”); } try { Object scopedInstance = scope.get(beanName, new ObjectFactory