《九》JavaScript 中的语句

任何复杂的程序逻辑都可以通过“顺序”，“分支”，“循环”三种基本的程序结构实现。

JS 一条语句的后面可以加分号，可以不加分号。在下面两种情况下，不加分号会报错。解决方法就是在上一条语句的末尾或者下一条语句的开头加分号。

1. 小括号开头的一条语句。

   var a = 1;
   (function(){
      console.log('2')
   }())
   

2. 中括号开头的一条语句。

   var a = 1
   ;[1,2,3].forEach(item => console.log(item))
   

分支语句:

if 分支语句：

1. 用来表示如果...就...。

    if (表达式) {
        // 表达式为 true 时执行内容；
    }
   

   如果 if 语句体中只有一行语句，可以省略大括号和换行。

   if (num > 5) console.log(num)
   

2. 用来表示如果...就...，否则...。

   if (表达式) {
       // 表达式为 true 时执行内容；
   } else {
       // 表达式为 false 时执行内容；
   }
   

3. 用来表示如果...就...，否则如果...就..，否则...。

   else if 分支暗含不符合之前所有条件。

   if (表达式 1) {
        // 表达式 1 为 true 时执行内容；
   } else if (表达式 2) {
        // 表达式 1 为 false ，表达式 2 为 true 时执行内容；
   } else if (表达式 3) {
        // 表达式 1 为 false ，表达式 2 为 false ，表达式 3 为 true 时执行内容；
   } else {
        // 这个 else 可有可无，上述条件都不满足时执行这个 else 的内容；
   }
   

switch-case 分支语句：

程序会依次将 case 后面的值与 switch 圆括号中的变量进行全等比较，如果相同，则执行这条 case 冒号后面的内容，并且退出 switch-case 分支语句；default 表示都不匹配的情况下默认执行的内容。

switch-case 分支语句的用途：当一个变量被分类讨论的情形，使用 switch-case 分支语句代码会更加简洁。

 switch(变量){
     case 值 1：
       	执行内容 1；
       	break; // 必须调用 break 来当匹配完成时跳出 switch-case 分支语句，如果不写，则后面的所有 case 都将被视为匹配，直到遇到 break
     case 值 2：
     case 值 3: // 多条 case 可以共用一个语句体
       	执行内容 2 和 3；
       	break;
      default: // default 可写可不写
        执行内容；
}

var username = 'Tom';
switch(username){
    case 'Tom':
       console.log('老虎');
       break;
    case 'Mary':
    case 'Lee':
       console.log('狮子');
       break;
}

var username = 'Tom';
switch(username){
    case 'Tom':
       console.log('老虎');
    case 'Mary':
       console.log('狮子');
    case 'Lee':
       console.log('豹子');
    default: 
       console.log('没有匹配到值');
} // 会依次输出 老虎 狮子 豹子 没有匹配到值

循环语句：

for 是确定范围的循环；while 是不定范围的循环。也就是说，for 是明确知道开始和结束的范围，while 不知道。

for 循环语句：

for 循环语句的执行机制：

1. 首先执行语句 1。
2. 然后判断语句 2，如果满足则进入循环体执行语句 4，如果不满足则退出循环。
3. 语句 4 执行完毕，则执行语句 3。
4. 再次判断语句 2，如果满足则进入循环体执行语句 4，如果不满足则退出循环。
5. …

for(1初始值；2表达式；3步幅){
   4执行内容；
}

1—2(true)—4—3—2(true)—4—3—2……
1—2(true)—4—3—2(false)循环结束

// var i = 1：表示定义一个循环变量 i，并赋初始值为 1
// i <= 10：表示继续执行循环的条件，只要这个表达式为真，就会一直执行
// i++：用来更新循环变量，使循环变量的值越来越趋向终点
for(var i=1; i<=10; i++){
	console.log(i);
}

将 for 循环语句中的初始值、表达式、步幅省略之后，就会创建一个无限循环。

for(;;){
   ...//无限循环
}

for 循环语句的嵌套：

for (var i = 0; i < 3; i++) {
	for (var j = 0; j < 3; J++) {
		console.log(i, j)
	}
}

while 循环语句:

1初始值；
while (2表达式) {
    3执行内容；
    4步幅；
}

1—2(true)—3—4—2(true)—3—4……
1—2(false)直接中止循环

while 循环是先判断再执行，所以可能一次都执行不了。

var i=1;
while(i<=10){
   console.log(i);
   i++;
}

do-while 循环语句：

1初始值；
do {
    2执行内容；
     3步幅；
} while (4表达式)

1—2—3—4(true)—2—3—4(true)……
1—2—3—4(false)中止循环

do-while 循环是先执行再判断，所以不管条件是否成立，至少能够执行一次。

var i=1;
do {
   console.log(i);
   i++;
} while (i<=10)

label 语句:

使用 label 语句可以在代码中添加标签，以便由 break 或 continue 引用，从而返回到代码中特定的位置。可以用来跳出多层循环。

语法:：label: statement;

break 语句和 continue 语句:

break 语句用于完全结束一个循环，跳出循环体，开始执行循环后面的代码。

break 只能跳出一层循环。
break 是跳出循环，return false 是中止函数的执行。

continue 语句只是中止本次循环，接着开始执行下一次循环。

for(let i=0; i<5; i++) {
    if (i===3) break;
    console.log(i);
} // 输出 0,1,2

for (let i=0; i<=5; i++) {
    if (i===3) continue;
    console.log(i);
} // 输出 0,1,2,4,5

var num = 0;  
for(var i = 0; i < 10; i++)  {  
    for(var j = 0; j < 10; j++)  {  
        if(i == 5 && j == 5)  {  
            break;       　　             
         }  
        num++;  
    }  
}  
console.log(num); // 输出 95。当i==5&&j==5时跳出j循环，继续执行i==6，j==0...的循环

//结合 label 语句
var num = 0;  
outer: for(var i = 0; i < 10; i++)  {  
    　for(var j = 0; j < 10; j++)  {  
        　  if(i == 5 && j == 5)  {  
            　　    break outer;  
       　　 }  
       　　num++;  
    　  }  
 }  
console.log(num); // 输出55。当i==5&&j==5时跳出到outPoint，也就是i循环之外，不再继续执行

 var num = 0;  
for(var i = 0; i < 10; i++)  {  
    　for(var j = 0; j < 10; j++)  {  
        　  if(i == 5 && j == 5)  {  
            　　continue ;  
       　　  }  
       　　 num++;  
    　 }  
}  
console.log(num); // 输出99。只跳过i==5&&j==5

var num = 0;  
outer:  for(var i = 0; i < 10; i++)  {  
    　 for(var j = 0; j < 10; j++)  {  
        　   if(i == 5 && j == 5)  {  
            　　continue outer;  
       　　  }  
       　　 num++;  
    　  }  
}  
console.log(num);//输出95。当i==5&&j==5时跳出到outPoint，也就是i循环之外，但再继续执行i==6&&j==0...

with 语句:

引用对象，并对该对象上的属性进行操作，可以省略重复书写该对象的名称，起到简化书写的作用。

大量使用with语句会导致性能下降，同时也会给调试代码造成困难。

var qs=location.search.substring(1);
var hostName=location.hostname;
var url=location.href;

 //使用with语句
with(location){
     var qs=search.substring(1);
     var hostName=hostname;
     var url=href;
}

try-catch 语句:

把所有可能会抛出错误的代码都放在try语句块中，把用于错误处理的代码放在catch块中。如果try块中的任何代码发生了错误，就会立即退出try块，而去执行catch块。这时，catch块会接收到一个包含错误信息的对象。所有浏览器共同的保存着一个错误信息对象的message属性。

try {
     window.boxFunction(); //调用不存在的函数
} catch (error) {
     alert(error.message);
}

finally()子句：虽然在try-catch语句中finally子句是可选的，但finally子句一经使用，其代码无论如何都会被执行。换句话说，try语句块中的代码全部正常执行，finally子句会执行；如果因为出错而执行了catch语句块，finally子句照样还会执行。只要代码中包含finally子句，则无论try或catch语句块中包含什么样的代码——甚至return语句，都不会阻止finally子句的执行。

function testFinally() {
   try {
       console.log(1);
   } catch (error) {
       console.log(2);
   } finally {
      console.log(0);
   }
}
testFinally(); //输出1和0