第五章：语句

表达式语句

        具有副作用的表达式是JavaScript中最简单的语句，这里的副作用指的是对变量产生的影响，最显著的是改变其值。

        赋值语句是一类比较重要的表达式语句，例如：

let a = 1;
a += 1;
a++;  //递增++和递减--运算符和赋值语句有关，它们的作用是改变一个变量的值，
      //就像执行一条赋值语句一样
a--;

        函数调用是表达式语句的另一个大类，例如：

let a = "Hello";
alert(a);
window.close();

        虽然这些客户端函数调用都是表达式，但它们都对web浏览器造成了一些影响，所有我们认为它们也是语句。

复合语句和空语句

        可以用逗号运算符将几个表达式连接在一起，形成一个表达式：

let a = 1, b = 2, c = 3;    //等价于let a = 1; let b = 2; let c = 3;

        同样，js中还可以将多条语句联合在一起，形成一条复合语句（compound statement），只需使用花括号将多条语句括起来即可：

{
    let x = -1;
    Math.abs(x);
    console.log(x);
}

        关于语句有几点需要注意：

        ①语句块的结尾不需要分号，块中的原始语句必须以分号结束，但语句块不需要；

        ②语句块中的行都有缩进，这不是必须的，但整齐的缩进能让代码可读性更强，更容易理解；

        ③js中没有块级作用域，在语句块中声明的变量并不是语句块中私有的。

        在js中，当希望多条语句被当作一条语句使用时，使用复合语句来替代，空语句（empty statement）则相反，它允许包含0条语句的语句，空语句直接使用分号（;），js解释器在执行空语句时它显然不会执行任何动作，但实践证明，当创建一个具有空语句的循环体时，有时是很有用的：

let a = new Array(7);    //创建一个空数组
for(let i = 0; i < a.length; a[i++] = 0);

声明语句

        关键字var用来声明一个或多个变量，语法如下：

var a;    //没有指定初始化表达式时，该变量的初始值为undefined
a = 1;
var b = 2;

//目前非全局变量推荐使用let 关键字，如
let a;
a = 1;
let b = 2;

        关键字function用来定义函数，函数饿定义也可以写成语句的形式：

var f = function(x){return x+1;}  //将表达式赋值给一个变量
function f(x){return x+1;}        //含有变量名的语句

条件语句

        条件语句是通过判断指定表达式的值来决定执行还是跳过某些语句，这些语句是代码的“决策点”，也称为“分支”。

if

        if语句是一种基本的控制语句，if可单独使用，也可与else结合使用，表示2条分支：

let a = 4;
if(a > 3){
    console.log(a);
}

if(a > 3){
    console.log(a);
}else{
    a -= 1;
}

else if

        如果条件语句的分支多于2条，可使用else if，例如：

let a = 4;
if(a < 3){
    a += 1;
}else if(a < 6){    //注意分支是按照顺序执行的，先判断是否<3,再判断是否<6
   console.log(a);  //这里等价于3 < a < 6

}else{              //这里等价于 a > 6
   a -= 1;
}

switch

        if相关语句是通过判断不通的条件来执行不同的分支，不同的分支依赖于不同的表达式，当所有分支都依赖于同一个表达式时，if相关语句并不是最佳解决方案，这种情况下，重复计算多条if语句中的表达式是非常浪费的做法，可使用switch case进行条件匹配来执行相应语句：

let a = 2;
switch(a){
    case 1:
        //执行代码块1
    break;
    case 2:
        //执行代码块2
    break;
    case 3:
        //执行代码块3
    break;
    default:
        //所有条件都不匹配时执行
    break;
}

        注意每个case语句块的结尾处都使用了关键字break，用于跳出switch或循环语句。

循环语句

        如果条件语句是分支，循环语句则是回路，用于重复执行满足条件的语句块。

while

let a = 4;
while(a > 0){    //只要满足a > 0花括号中的语句就会反复执行，这里要注意避免死循环
    console.log(a);
    a--;
}

do/while

        do/while循环与while循环非常相似，不过do/while循环的是在尾部检测是否符合循环条件，这意味着do/while循环体至少会执行一次：

let a = 4;
do {
    console.log(a);
    a--;
}while(a > 4)  //上面的语句块执行了一次之后才会进行循环判断

for

        for循环是很常用的循环语句：

let a = [1,2,3,4];
for(let i = 0; i < a.length; i++){
    console.log(a[i]);
}

for/in

        for/in语句也使用for关键字，但它是和常规的for循环完全不同的一类循环：

let a = [1,2,3,4];
for(let m in a){
    console.log(m);    //0,1,2,3
}

for(let n in a){
    console.log(a[n]);  //1,2,3,4
}

        for/in循环并不会遍历对象的所有属性，只有“可枚举”（enumerable）的属性才会遍历到。

跳转

标签语句

        语句是可以添加标签的，标签是由语句前的标识符和冒号组成：

        identifier : statement

        通过给语句定义标签，就可以在程序的任何地方通过标签名引用这条语句，标签名不能是保留字。

let a = 4;
mylabel:for(let i = 0; i < 7; i++){
    if(i == a){
        break mylabel;
    }
}

break

        单独使用break语句的作用是立即退出最内层的循环或switch语句，也能与标签配合使用（上面的例子就是）。在循环中，不论出于什么原因，只要不想继续执行整个循环，就可以使用break提前退出，在终止条件非常复杂的循环中，使用break是非常实用的。

continue

        continue语句和break语句非常类似，但它不是退出循环，而是转而执行下一次循环：

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

        continue也可与标签配合使用。

return

        return一般用于指定函数调用后的返回值，只能在函数体内出现，否则会报语法错误。当执行到return语句时，函数终止执行，并有返回值给调用程序。如果没有return语句，则函数调用依次执行函数体内的每一条语句，直至函数结束，并不是说return一定要放在函数最后，即使在执行return语句时还有很多后续代码没有执行到，这时函数也还会返回调用程序：

//求绝对值
function num(m){
    if(m >= 0){
        return m;
    }else{
        return -m;
    }
}

num(3);
num(-4);

throw

        所谓异常（exception）是当发生了某种异常情况或错误时产生的一个信号。抛出异常，就是用信号通知发生了错误或异常状况。捕获异常是指处理这个信号，即采取必要的手段从异常中恢复。可使用throw抛出异常：

        throw expression；

        expression可以是任意类型的，js解释器抛出异常时通常采用Error类型和其子类型，一个Error对象有一个name属性表示错误类型，一个message属性用来存放传递给构造函数的字符串：

function factorial(x){
    if(x < 0) throw new Error("x不能为负数！");
    let f = 1
    for(f; x > 1; f *= x,x--);
    return f;
}

try/catch/finally

        try/catch/finally语句是js异常处理机制，try从句定义了需要处理的异常所在的代码块，catch从句跟随在try从句之后，当try从句内部某处发生异常时，调用catch内的代码逻辑。catch从句后跟随finally块，用于放置清理代码，不管try中是否产生异常，finally中的逻辑总是会执行。尽管catch与finally都是可选的，但try至少需要二者之一与之组成完整的语句，三个语句块内的代码都需要使用花括号括起来：

try{
    let n = Number(prompt("请输入一个正整数",""));
    let m = factorial(n);
}catch(ex){
    alert(ex)
}finally{
    alert("finally!")
}

        下表列出了这些js语句：

语句	语法	用途
break	break [label];	退出最内层循环或者退出switch语句，又或者退出label指定的语句
case	case expression;	在switch语句中标记一条语句
continue	continue [label];	跳过此次循环并开始下一次循环（或label指定的循环）
debugger	debugger;	断点器调试
default	default;	switch语句中没有匹配的case时默认执行
do/while	do statement while(expression)	while循环的另一种方式
empty	;	什么都不做
for	for(init; test; incr) statement	for循环
for/in	for(v in object) statement	遍历对象的属性
function	function name(param){body}	声明一个函数
if/else	if(expr){ statement1 } else { statement2 }	分支判断
label	label : statement	给语句块设置标签
return	return [expression];	函数返回值
switch	switch (expression) { statements }	switch分支判断，与case或default联合使用
throw	throw expression;	抛出异常
try	try { statements } [ catch { handler statements } ] [ finally { cleanup statements } ]	捕获异常
use strict	“use strict”	对脚本或函数应用严格模式
var	var name = ...;	声明并初始化一个或多个变量
while	while( expression ){ statements }	while循环
with	with ( object ) statement	扩展作用域链（不赞成使用）