1.什么是循环依赖？
 
它发生在bean A依赖于另一个bean B时，bean B依赖于bean A：
 
豆A→豆B→豆A
 
当然，我们可以有更多的暗示：
 
豆A→豆B→豆C→豆D→豆E→豆A
 
2.春天会发生什么
 
当Spring上下文加载所有bean时，它会尝试按照它们完全工作所需的顺序创建bean。例如，如果我们没有循环依赖，如下例所示：
 
豆A→豆B→豆C.
 
Spring将创建bean C，然后创建bean B（并将bean注入其中），然后创建bean A（并将bean B注入其中）。
 
但是，当具有循环依赖时，Spring无法决定应该首先创建哪个bean，因为它们彼此依赖。在这些情况下，Spring将在加载上下文时引发BeanCurrentlyInCreationException。
 
使用构造函数注入时，它可能发生在Spring中; 如果您使用其他类型的注入，则不应该发现此问题，因为依赖项将在需要时注入，而不是在上下文加载时注入。
 
3.一个快速示例
 
让我们定义两个相互依赖的bean（通过构造函数注入）：
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
 
@Component
 
public class CircularDependencyA {
 
 
 
    private CircularDependencyB circB;
 
 
 
    @Autowired
 
    public CircularDependencyA(CircularDependencyB circB) {
 
        this.circB = circB;
 
    }
 
}
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
 
@Component
 
public class CircularDependencyB {
 
 
 
    private CircularDependencyA circA;
 
 
 
    @Autowired
 
    public CircularDependencyB(CircularDependencyA circA) {
 
        this.circA = circA;
 
    }
 
}
 
现在我们可以为测试编写一个Configuration类，让我们称之为TestConfig，它指定要扫描组件的基础包。假设我们的bean在包“ com.baeldung.circulardependency ” 中定义：
 
 
1
 
2
 
3
 
4
 
 
@Configuration
 
@ComponentScan(basePackages = { "com.baeldung.circulardependency" })
 
public class TestConfig {
 
}
 
最后我们可以编写一个JUnit测试来检查循环依赖。测试可以为空，因为在上下文加载期间将检测循环依赖性。
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
 
@RunWith(SpringJUnit4ClassRunner.class)
 
@ContextConfiguration(classes = { TestConfig.class })
 
public class CircularDependencyTest {
 
 
 
    @Test
 
    public void givenCircularDependency_whenConstructorInjection_thenItFails() {
 
        // Empty test; we just want the context to load
 
    }
 
}
 
如果您尝试运行此测试，则会出现以下异常：
 
 
BeanCurrentlyInCreationException: Error creating bean with name 'circularDependencyA':
 
Requested bean is currently in creation: Is there an unresolvable circular reference?
 
4.解决方法
 
我们将展示一些最流行的方法来解决这个问题。
 
4.1。重新设计
 
如果您有循环依赖关系，则可能是您遇到了设计问题而且责任分离不清。您应该尝试正确地重新设计组件，以便它们的层次结构设计得很好，并且不需要循环依赖。
 
如果您无法重新设计组件（可能有许多可能的原因：遗留代码，已经过测试且无法修改的代码，没有足够的时间或资源来完成重新设计......），有一些可行的解决方法。
 
4.2。使用@Lazy
 
打破循环的一个简单方法是让Spring懒洋洋地初始化其中一个bean。那就是：它不是完全初始化bean，而是创建一个代理将它注入另一个bean。注入的bean只有在第一次需要时才会完全创建。
 
要使用我们的代码尝试此操作，您可以将CircularDependencyA更改为以下内容：
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
 
@Component
 
public class CircularDependencyA {
 
 
 
    private CircularDependencyB circB;
 
 
 
    @Autowired
 
    public CircularDependencyA(@Lazy CircularDependencyB circB) {
 
        this.circB = circB;
 
    }
 
}
 
如果您现在运行测试，您将看到此次错误不会发生。
 
4.3。使用Setter / Field Injection
 
最流行的解决方法之一，也是Spring文档提出的，是使用setter注入。
 
简单地说，如果你改变你的bean的连接方式，使用setter注入（或现场注入）而不是构造函数注入 - 这确实解决了这个问题。这样Spring就会创建bean，但是在需要之前不会注入依赖项。
 
让我们这样做 - 让我们改变我们的类以使用setter注入，并将另一个字段（消息）添加到CircularDependencyB，以便我们可以进行适当的单元测试：
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
12
 
13
 
14
 
 
@Component
 
public class CircularDependencyA {
 
 
 
    private CircularDependencyB circB;
 
 
 
    @Autowired
 
    public void setCircB(CircularDependencyB circB) {
 
        this.circB = circB;
 
    }
 
 
 
    public CircularDependencyB getCircB() {
 
        return circB;
 
    }
 
}
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
12
 
13
 
14
 
15
 
16
 
 
@Component
 
public class CircularDependencyB {
 
 
 
    private CircularDependencyA circA;
 
 
 
    private String message = "Hi!";
 
 
 
    @Autowired
 
    public void setCircA(CircularDependencyA circA) {
 
        this.circA = circA;
 
    }
 
 
 
    public String getMessage() {
 
        return message;
 
    }
 
}
 
现在我们必须对单元测试进行一些更改：
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
12
 
13
 
14
 
15
 
16
 
17
 
18
 
19
 
20
 
21
 
22
 
23
 
24
 
 
@RunWith(SpringJUnit4ClassRunner.class)
 
@ContextConfiguration(classes = { TestConfig.class })
 
public class CircularDependencyTest {
 
 
 
    @Autowired
 
    ApplicationContext context;
 
 
 
    @Bean
 
    public CircularDependencyA getCircularDependencyA() {
 
        return new CircularDependencyA();
 
    }
 
 
 
    @Bean
 
    public CircularDependencyB getCircularDependencyB() {
 
        return new CircularDependencyB();
 
    }
 
 
 
    @Test
 
    public void givenCircularDependency_whenSetterInjection_thenItWorks() {
 
        CircularDependencyA circA = context.getBean(CircularDependencyA.class);
 
 
 
        Assert.assertEquals("Hi!", circA.getCircB().getMessage());
 
    }
 
}
 
以下解释了上面的注释：
 
@Bean：告诉Spring框架必须使用这些方法来检索要注入的bean的实现。
 
@Test：测试将从上下文中获取CircularDependencyA bean并断言其CircularDependencyB已正确注入，检查其message属性的值。
 
4.4。使用@PostConstruct
 
打破循环的另一种方法是在其中一个bean上使用@Autowired注入依赖项，然后使用@PostConstruct注释的方法来设置其他依赖项。
 
我们的bean可以有以下代码：
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
12
 
13
 
14
 
15
 
 
@Component
 
public class CircularDependencyA {
 
 
 
    @Autowired
 
    private CircularDependencyB circB;
 
 
 
    @PostConstruct
 
    public void init() {
 
        circB.setCircA(this);
 
    }
 
 
 
    public CircularDependencyB getCircB() {
 
        return circB;
 
    }
 
}
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
12
 
13
 
14
 
15
 
 
@Component
 
public class CircularDependencyB {
 
 
 
    private CircularDependencyA circA;
 
     
 
    private String message = "Hi!";
 
 
 
    public void setCircA(CircularDependencyA circA) {
 
        this.circA = circA;
 
    }
 
     
 
    public String getMessage() {
 
        return message;
 
    }
 
}
 
我们可以运行我们以前的相同测试，因此我们检查是否仍然没有抛出循环依赖性异常并且正确地注入了依赖项。
 
4.5。实现ApplicationContextAware和InitializingBean
 
如果其中一个bean实现ApplicationContextAware，则bean可以访问Spring上下文，并可以从那里提取其他bean。实现InitializingBean我们指出这个bean必须在设置了所有属性后执行一些操作; 在这种情况下，我们想手动设置我们的依赖项。
 
我们的bean的代码是：
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
12
 
13
 
14
 
15
 
16
 
17
 
18
 
19
 
20
 
21
 
 
@Component
 
public class CircularDependencyA implements ApplicationContextAware, InitializingBean {
 
 
 
    private CircularDependencyB circB;
 
 
 
    private ApplicationContext context;
 
 
 
    public CircularDependencyB getCircB() {
 
        return circB;
 
    }
 
 
 
    @Override
 
    public void afterPropertiesSet() throws Exception {
 
        circB = context.getBean(CircularDependencyB.class);
 
    }
 
 
 
    @Override
 
    public void setApplicationContext(final ApplicationContext ctx) throws BeansException {
 
        context = ctx;
 
    }
 
}
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
12
 
13
 
14
 
15
 
16
 
 
@Component
 
public class CircularDependencyB {
 
 
 
    private CircularDependencyA circA;
 
 
 
    private String message = "Hi!";
 
 
 
    @Autowired
 
    public void setCircA(CircularDependencyA circA) {
 
        this.circA = circA;
 
    }
 
 
 
    public String getMessage() {
 
        return message;
 
    }
 
}
 
同样，我们可以运行上一个测试，看到没有抛出异常并且测试按预期工作。
 
5.结论
 
在Spring中有很多方法可以处理循环依赖。首先要考虑的是重新设计bean，这样就不需要循环依赖：它们通常是可以改进的设计的症状。
 
但是如果你的项目中绝对需要循环依赖，那么你可以遵循这里建议的一些解决方法。
 
优选的方法是使用二次注射。但是还有其他选择，通常基于阻止Spring管理bean的初始化和注入，以及使用一种策略或另一种策略自己做。
 
你可以找到上面显示的豆这里，和单元测试在这里。

概述
 
Python提供了for循环和while循环（在Python中没有do..while循环）
 
 
 
while循环
 
语法
 
Python 编程中 while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。其基本形式为：
 
while 判断条件：
    执行语句……
 
执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。 
 当判断条件假false时，循环结束。
 
流程图
 
执行流程图如下：
 
 
栗子
 
#!/usr/bin/python

count = 0
while (count < 9):
   print 'The count is:', count
   count = count + 1

print "Good bye!"
 
结果：
 
The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
Good bye!
 
while 语句时还有另外两个重要的命令 continue，break 来跳过循环， 
 continue 用于跳过该次循环， 
 break 则是用于退出循环，
 
此外“判断条件”还可以是个常值，表示循环必定成立，具体用法如下：
 
# continue 和 break 用法

i = 1
while i < 10:   
    i += 1
    if i%2 > 0:     # 非双数时跳过输出
        continue
    print i         # 输出双数2、4、6、8、10



i = 1
while 1:            # 循环条件为1必定成立
    print i         # 输出1~10
    i += 1
    if i > 10:     # 当i大于10时跳出循环
        break
 
无限循环
 
如果条件判断语句永远为 true，循环将会无限的执行下去
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-

var = 1
while var == 1 :  # 该条件永远为true，循环将无限执行下去
   num = raw_input("Enter a number  :")
   print "You entered: ", num

print "Good bye!"
 
Enter a number  :20
You entered:  20
Enter a number  :29
You entered:  29
Enter a number  :3
You entered:  3
Enter a number between :Traceback (most recent call last):
  File "test.py", line 5, in <module>
    num = raw_input("Enter a number :")
KeyboardInterrupt
 
注意：以上的无限循环你可以使用 CTRL+C 来中断循环。
 
循环使用 else 语句
 
在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。
 
#!/usr/bin/python

count = 0
while count < 5:
   print count, " is  less than 5"
   count = count + 1
else:
   print count, " is not less than 5"
 
结果：
 
0 is less than 5
1 is less than 5
2 is less than 5
3 is less than 5
4 is less than 5
5 is not less than 5
 
简单语句组
 
类似if语句的语法，如果你的while循环体中只有一条语句，你可以将该语句与while写在同一行中， 如下所示：
 
#!/usr/bin/python

flag = 1

while (flag): print 'Given flag is really true!'

print "Good bye!"
 
注意：以上的无限循环你可以使用 CTRL+C 来中断循环。
 
 
for循环
 
Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
 
语法
 
for循环的语法格式如下：
 
for iterating_var in sequence:
   statements(s)
 
流程图
 
 
栗子
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-

for letter in 'Python':     # 第一个实例
   print '当前字母 :', letter

fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        # 第二个实例
   print '当前字母 :', fruit

print "Good bye!"
 
结果：
 
当前字母 : P
当前字母 : y
当前字母 : t
当前字母 : h
当前字母 : o
当前字母 : n
当前字母 : banana
当前字母 : apple
当前字母 : mango
Good bye!
 
通过序列索引迭代
 
另外一种执行循环的遍历方式是通过索引，如下实例：
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-

fruits = ['banana', 'apple',  'mango']
for index in range(len(fruits)):
   print '当前水果 :', fruits[index]

print "Good bye!"
 
以上实例输出结果：
 
当前水果 : banana
当前水果 : apple
当前水果 : mango
Good bye!
 
以上实例我们使用了内置函数 len() 和 range(),函数 len() 返回列表的长度，即元素的个数。 range返回一个序列的数。
 
循环使用 else 语句
 
在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-

for num in range(10,20):  # 迭代 10 到 20 之间的数字
   for i in range(2,num): # 根据因子迭代
      if num%i == 0:      # 确定第一个因子
         j=num/i          # 计算第二个因子
         print '%d 等于 %d * %d' % (num,i,j)
         break            # 跳出当前循环
   else:                  # 循环的 else 部分
      print num, '是一个质数'
 
以上实例输出结果：
 
10 等于 2 * 5
11 是一个质数
12 等于 2 * 6
13 是一个质数
14 等于 2 * 7
15 等于 3 * 5
16 等于 2 * 8
17 是一个质数
18 等于 2 * 9
19 是一个质数
 
 
嵌套循环 -在while循环体中嵌套for循环
 
Python for 循环嵌套语法
 
for iterating_var in sequence:
   for iterating_var in sequence:
      statements(s)
   statements(s)
 
Python while 循环嵌套语法
 
while expression:
   while expression:
      statement(s)
   statement(s)
 
你可以在循环体内嵌入其他的循环体，如在while循环中可以嵌入for循环， 反之，你可以在for循环中嵌入while循环。
 
栗子
 
以下实例使用了嵌套循环输出2~100之间的素数：
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-

i = 2
while(i < 100):
   j = 2
   while(j <= (i/j)):
      if not(i%j): break
      j = j + 1
   if (j > i/j) : print i, " 是素数"
   i = i + 1

print "Good bye!"
 
以上实例输出结果:
 
2 是素数
3 是素数
5 是素数
7 是素数
11 是素数
13 是素数
17 是素数
19 是素数
23 是素数
29 是素数
31 是素数
37 是素数
41 是素数
43 是素数
47 是素数
53 是素数
59 是素数
61 是素数
67 是素数
71 是素数
73 是素数
79 是素数
83 是素数
89 是素数
97 是素数
Good bye!
 

python range() 函数可创建一个整数列表，一般用在 for 循环中。
函数语法range(start, stop[, step])
参数说明：
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
实例
>>>range(10) # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11) # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5) # 步长为 5
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3) # 步长为 3
[0, 3, 6, 9]
>>> range(0, -10, -1) # 负数
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]
以下是 range 在 for 中的使用，循环出runoob 的每个字母:
>>>x = 'runoob'
>>> for i in range(len(x)) :
... print(x[i])
...
r
u
n
o
o
b
>>>
在tensorflow python 3.6的环境下，range函数中实参必须为int型，否则报错
def load_dataset(data_dir, img_size):
"""img_files = os.listdir(data_dir)
test_size = int(len(img_files)*0.2)
test_indices = random.sample(range(len(img_files)),test_size)
for i in range(len(img_files)):
#img = scipy.misc.imread(data_dir+img_files[i])
if i in test_indices:
test_set.append(data_dir+"/"+img_files[i])
else:
train_set.append(data_dir+"/"+img_files[i])
return"""
global train_set
global test_set
imgs = [] 
img_files = os.listdir(data_dir)
for img in img_files:
try:
tmp= scipy.misc.imread(data_dir+"/"+img)
x,y,z = tmp.shape
coords_x = x // img_size
coords_y = y // img_size
#coords_y = y / img_size
# coords_x = x / img_size
#print (coords_x)
coords = [ (q,r) for q in range(coords_x) for r in range(coords_y) ]
for coord in coords:
imgs.append((data_dir+"/"+img,coord))
except:
print ("oops")
test_size = min(10,int( len(imgs)*0.2))
random.shuffle(imgs)
test_set = imgs[:test_size]
train_set = imgs[test_size:][:200]
return
def get_batch(batch_size,original_size,shrunk_size):
global batch_index
"""img_indices = random.sample(range(len(train_set)),batch_size)
for i in range(len(img_indices)):
index = img_indices[i]
img = scipy.misc.imread(train_set[index])
if img.shape:
img = crop_center(img,original_size,original_size)
x_img = scipy.misc.imresize(img,(shrunk_size,shrunk_size))
x.append(x_img)
y.append(img)"""
max_counter = len(train_set)/batch_size
counter = batch_index % max_counter
#counter = tf.to_int32(batch_index % max_counter)
window = [x for x in range(int(counter*batch_size),int((counter+1)*batch_size))]
#window = [x for x in range(tf.to_int32(counter*batch_size),tf.to_int32((counter+1)*batch_size))]
#window = [x for x in np.arange((counter*batch_size),((counter+1)*batch_size))]
#a1=tf.cast(counter*batch_size,tf.int32)
#a2=tf.cast((counter+1)*batch_size,tf.int32)
#window = [x for x in range(a1,a2)]
#window = [x for x in np.arange(a1,a2)]
#win2 = tf.cast(window,tf.int32)
#win2 = tf.to_int32(window)
#win2 = tf.to_int64(window)
imgs = [train_set[q] for q in window]
x = [scipy.misc.imresize(get_image(q,original_size),(shrunk_size,shrunk_size)) for q in imgs]#scipy.misc.imread(q[0])[q[1][0]*original_size:(q[1][0]+1)*original_size,q[1][1]*original_size:(q[1][1]+1)*original_size].resize(shrunk_size,shrunk_size) for q in imgs]
y = [get_image(q,original_size) for q in imgs]#scipy.misc.imread(q[0])[q[1][0]*original_size:(q[1][0]+1)*original_size,q[1][1]*original_size:(q[1][1]+1)*original_size] for q in imgs]
batch_index = (batch_index+1)%max_counter
以上就是range在python中是什么意思的详细内容，更多请关注php中文网其它相关文章！
本文原创发布php中文网，转载请注明出处，感谢您的尊重！

          【JS-task4】  

            return的用法是什么？若用在for循环中，还会执行下一次循环吗？ 

             分享人：陈星宇

         

         

             目录 

             1.背景介绍 

             2.知识剖析 

             3.常见问题 

             4.解决方案 

             5.编码实战 

             6.扩展思考 

             7.参考文献 

             8.更多讨论 

         

         

一.背景介绍 

         

         

             什么是return? 

             

                 return 语句会终止函数的执行，并返回函数的值。 

            语法：

                return value;

            可选项 value指定返回的值。如果忽略则返回undefined.

           


            在函数中 ，return 语句用于终止一个函数的执行，并返回值value。
            如果value被省略或在函数内没有 return 语句被执行，则函数返回undefined。 
             





         

         

二.知识剖析 

         

         

             return语句的用法 


  

             1、中止函数的执行，并返回函数执行的结果</h4>

             语法为：return+表达式 

              return 返回的值可以是任何数据类型 

           


    function type(){

                   var a=1;

                   var b=2;

                   return a+b;    
//返回数值

                   alert('a')

                  }

                type();


                console.log(type());

                function string(){

                   return "字符串"  
//返回字符串

                }


                console.log(string());

                function arr(){

                  return [1,2,3,4]     
//返回数组

                }


                console.log(arr());

                function object(){

                return {"name":"cxx", "age":13}  
//返回对象

                }

                console.log(object());

            

         

             2、使用return阻止某些浏览器默认的行为

             语法为：return false; 

             可以在a标签中实践一下。 

             请看demo的例子： 

                          

                     <span class="ojbk">

                         <a id="btn1" href="https://www.baidu.com/">按钮1</a>

                         <a id="btn2" href="https://www.baidu.com/">按钮2</a>

                     </span>

                     <script>

                         $('#btn1').on('click',function () {//点击按钮1要发生的事

                             alert("按钮1测试弹窗（默认情况会跳转）");

                             return true;

                         });

                         $('#btn2').on('click',function () {//点击按钮2要发生的事

                             alert("按钮2测试弹窗（return false阻止默认跳转）");

                             return false;

                         });

                     </script>





         

三.常见问题  

                   


                 1.若return用在for循环中，还会执行下一次循环吗？ 
                 2.除了return之外，还有哪些语句可以跳出循环？ 
                 3.多层for循环return会跳出一层还是直接跳出                
                 4.return和break和continue区别
四. 解决方案  

         

        
 回答问题1：

             代码示例: 

        

                function jumpLoop() {

                   result = []

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

                      result.push(i)

                      if(i===8){

                         return result;

                      }

                   }

                }

                console.log(jumpLoop())

           

             
我们可以看到，for循环只返回return所返回的值，并不会执行下一次循环。 

         

         

            
回答问题2： 除了return之外，还有哪些语句可以跳出循环？

             

                 (1)break 


                

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

                       console.log(i);

                       if(i==5){break;}

                    }

                

                 上面这个break实例，输出的结果为：12345，当i的值等于5的时候直接通过break跳出了循环，不再继续往下运行。 

                       

                 (2)continue 

               

                        for(var i=1;i<=10;i++){

                            if (i === 3||i===7) continue;

                            console.log(i);

                        }

                   


                 上面这个continue实例，输出的结果为：124568910，当i的值等于3或者7的时候直接跳过，继续执行循环。 
     
  回答问题3       
               多层for循环中，return如果跳出循环，只会跳出它所在的那一层循环，并不影响其他层的循环。 
  回答问题4  
                break 跳出总上一层循环，不再执行循环(结束当前的循环体)
                continue 跳出本次循环，继续执行下次循环(结束正在执行的循环 进入下一个循环条件) 
                return 程序返回，不再执行下面的代码(结束当前的方法 直接返回) 
         

五.编码实战  

                         

六.扩展思考 

                 jq的return false 和原生的return false有什么区别 

             

             

                1.在jq中使用return false实际上它完成了3件事：

                    1.event.preventDefault()


                    preventDefault() 方法阻止元素发生默认的行为 
                    2.event.stopPropagation()


                    event.stopPropagation()阻止捕获和冒泡阶段中当前事件的进一步传播 
                    3.终止函数的执行并返回结果。

                    jq的return false会同时阻止浏览器默认事件的发生，阻止事件的冒泡，并且返回函数值，而在原生js中，return并                      不能阻止事件的冒泡.

                 

             

             

                2.JS中return False 就相当于终止符,终止默认的事件行为

             

         

 七.参考文献 

               参考1：event.preventDefault() vs. return false

               参考2：javascript中break，continue和return语句用法小结

               参考3： js中return的用法