JavaScript控制流语句的使用
条件语句：if...else
在JavaScript中，if...else语句是最基本的条件判断结构。它根据给定的条件来决定执行哪一段代码块。其基本语法如下：
if (condition) {
// 如果条件为真，执行这里的代码
console.log('条件为真');
} else {
// 如果条件为假，执行这里的代码
console.log('条件为假');
}
在这里，condition是一个布尔表达式。如果condition的求值结果为true，则执行if块中的代码；否则，执行else块中的代码。
例如，我们来判断一个数字是否为正数：
let num = 10;
if (num > 0) {
console.log(num + '是正数');
} else {
console.log(num + '不是正数');
}
这段代码中，变量num的值为10，num > 0这个条件为true，所以会输出10是正数。
嵌套的if...else
有时候，我们需要在一个条件判断的基础上再进行进一步的条件判断，这就需要用到嵌套的if...else语句。例如：
let score = 85;
if (score >= 60) {
if (score >= 80) {
console.log('成绩良好');
} else {
console.log('成绩及格');
}
} else {
console.log('成绩不及格');
}
在这个例子中，首先判断score是否大于等于60。如果是，再进一步判断是否大于等于80，根据不同的结果输出不同的信息。
if...else if...else
当有多个互斥的条件需要判断时，可以使用if...else if...else结构。其语法如下：
if (condition1) {
// 如果condition1为真，执行这里的代码
console.log('condition1为真');
} else if (condition2) {
// 如果condition1为假且condition2为真，执行这里的代码
console.log('condition2为真');
} else {
// 如果所有条件都为假，执行这里的代码
console.log('所有条件都为假');
}
例如，根据学生的成绩等级输出对应的评价：
let grade = 'B';
if (grade === 'A') {
console.log('优秀');
} else if (grade === 'B') {
console.log('良好');
} else if (grade === 'C') {
console.log('中等');
} else {
console.log('需要努力');
}
这里根据grade变量的值进行不同的判断，并输出相应的评价。
三元运算符
三元运算符是if...else语句的一种简洁写法，它的语法是：condition? expression1 : expression2。如果condition为true，则返回expression1的值；否则，返回expression2的值。
例如，我们可以用三元运算符来判断一个数的奇偶性：
let num = 7;
let result = num % 2 === 0? '偶数' : '奇数';
console.log(result);
在这个例子中，num % 2 === 0是条件判断。如果num除以2的余数为0，即num是偶数，result就会被赋值为偶数；否则，result会被赋值为奇数。
三元运算符可以嵌套使用，但嵌套过多会使代码可读性变差。例如：
let num = 15;
let result = num < 10? '小于10' : (num < 20? '10到20之间' : '大于等于20');
console.log(result);
这里先判断num是否小于10，如果是，返回小于10。如果不是，再判断num是否小于20，根据结果返回不同的字符串。
switch语句
switch语句用于基于不同的条件执行不同的代码块。它的基本语法如下：
switch (expression) {
case value1:
// 如果expression等于value1，执行这里的代码
console.log('匹配value1');
break;
case value2:
// 如果expression等于value2，执行这里的代码
console.log('匹配value2');
break;
default:
// 如果expression不匹配任何case的值，执行这里的代码
console.log('不匹配任何值');
}
expression会与每个case后面的值进行比较。如果找到匹配的值，就会执行相应case块中的代码，直到遇到break语句为止。如果没有匹配的值，就会执行default块中的代码（default块是可选的）。
例如，根据星期几的数字输出对应的星期几的名称：
let day = 3;
switch (day) {
case 1:
console.log('星期一');
break;
case 2:
console.log('星期二');
break;
case 3:
console.log('星期三');
break;
case 4:
console.log('星期四');
break;
case 5:
console.log('星期五');
break;
case 6:
console.log('星期六');
break;
case 7:
console.log('星期日');
break;
default:
console.log('无效的数字');
}
在这个例子中，day的值为3，所以会输出星期三。
穿透现象
如果在case块中没有break语句，就会发生穿透现象。即当找到一个匹配的case后，会继续执行后面case块中的代码，直到遇到break或者switch语句结束。例如：
let num = 2;
switch (num) {
case 1:
console.log('一');
case 2:
console.log('二');
case 3:
console.log('三');
default:
console.log('其他');
}
这里num的值为2，匹配到case 2，但由于没有break，会继续执行case 3和default块中的代码，最终输出：
二
三
其他
虽然穿透现象在某些特定场景下可能有用，但大多数情况下会导致意外的结果，所以要谨慎使用，确保每个case块中都有合适的break语句，除非你有意利用穿透特性。
循环语句：for循环
for循环是JavaScript中最常用的循环结构之一，用于重复执行一段代码。它的基本语法如下：
for (initialization; condition; increment) {
// 循环体，重复执行的代码
console.log('循环中');
}
initialization：在循环开始前执行一次，通常用于初始化循环变量。condition：每次循环开始时检查的条件。如果条件为true，则执行循环体；如果为false，则终止循环。increment：在每次循环结束后执行，通常用于更新循环变量。
例如，我们可以使用for循环来计算1到10的累加和：
let sum = 0;
for (let i = 1; i <= 10; i++) {
sum += i;
}
console.log('1到10的累加和为：' + sum);
在这个例子中，i是循环变量，初始值为1。每次循环检查i <= 10是否为真，如果为真，就执行循环体，将i加到sum中，然后i自增1。当i大于10时，循环结束，输出累加和。
嵌套for循环
for循环可以嵌套使用，用于处理多维数据结构等场景。例如，我们可以用嵌套for循环来打印一个九九乘法表：
for (let i = 1; i <= 9; i++) {
for (let j = 1; j <= i; j++) {
let result = i * j;
process.stdout.write(j + '×' + i + '=' + result + '\t');
}
console.log();
}
这里外层for循环控制行数，内层for循环控制每行的乘法运算个数。通过内层循环的j和外层循环的i相乘，输出乘法表的每一项。process.stdout.write用于在同一行输出内容，\t是制表符，用于对齐输出，console.log()用于换行。
for...of循环
for...of循环是ES6引入的新循环结构，用于遍历可迭代对象（如数组、字符串、Map、Set等）。其语法如下：
let arr = [1, 2, 3, 4];
for (let value of arr) {
console.log(value);
}
在这个例子中，value会依次取数组arr中的每一个元素，并输出。
对于字符串，for...of循环会按字符遍历：
let str = 'hello';
for (let char of str) {
console.log(char);
}
这里会依次输出h、e、l、l、o。
与for...in的区别
for...in循环也用于遍历对象，但它遍历的是对象的可枚举属性名。而for...of遍历的是对象的实际值。例如：
let obj = {a: 1, b: 2, c: 3};
for (let key in obj) {
console.log(key);
}
// 输出：a b c
let arr = [1, 2, 3];
for (let index in arr) {
console.log(index);
}
// 输出：0 1 2
for (let value of arr) {
console.log(value);
}
// 输出：1 2 3
从这个例子可以看出，for...in在遍历数组时得到的是索引，而for...of得到的是数组元素的值。在遍历对象时，for...in得到的是属性名。并且for...in会遍历对象原型链上的可枚举属性，而for...of只针对对象自身的可迭代值。
while循环
while循环会在指定条件为真时，重复执行一段代码。其基本语法如下：
while (condition) {
// 循环体，条件为真时执行的代码
console.log('循环中');
}
例如，我们可以用while循环来计算1到100的偶数和：
let sum = 0;
let num = 2;
while (num <= 100) {
sum += num;
num += 2;
}
console.log('1到100的偶数和为：' + sum);
在这个例子中，num初始值为2，每次循环检查num <= 100是否为真，如果为真，就将num加到sum中，然后num增加2。当num大于100时，循环结束，输出偶数和。
do...while循环
do...while循环与while循环类似，但它会先执行一次循环体，然后再检查条件。其语法如下：
do {
// 循环体，先执行一次
console.log('循环中');
} while (condition);
例如：
let num = 1;
do {
console.log(num);
num++;
} while (num <= 5);
在这个例子中，无论num <= 5条件是否为真，都会先执行一次循环体，输出1，然后num自增1。之后每次循环检查条件，直到num大于5时循环结束。
控制循环的语句：break和continue
break
break语句用于立即终止当前循环（无论是for、while还是do...while循环）。例如：
for (let i = 1; i <= 10; i++) {
if (i === 5) {
break;
}
console.log(i);
}
在这个例子中，当i等于5时，执行break语句，循环立即终止，所以只会输出1到4。
在嵌套循环中，break语句默认只终止最内层的循环。例如：
for (let i = 1; i <= 3; i++) {
for (let j = 1; j <= 3; j++) {
if (i === 2 && j === 2) {
break;
}
console.log(i + ','+ j);
}
}
这里当i为2且j为2时，内层循环终止，但外层循环会继续执行，输出结果为：
1, 1
1, 2
1, 3
2, 1
3, 1
3, 2
3, 3
如果要终止外层循环，可以给外层循环起一个标签，然后在break语句中使用这个标签。例如：
outer:
for (let i = 1; i <= 3; i++) {
for (let j = 1; j <= 3; j++) {
if (i === 2 && j === 2) {
break outer;
}
console.log(i + ','+ j);
}
}
这样当i为2且j为2时，会终止外层循环，输出结果为：
1, 1
1, 2
1, 3
continue
continue语句用于跳过当前循环的剩余部分，直接开始下一次循环。例如：
for (let i = 1; i <= 10; i++) {
if (i % 2 === 0) {
continue;
}
console.log(i);
}
在这个例子中，当i是偶数时，执行continue语句，跳过本次循环的console.log(i)部分，直接开始下一次循环。所以只会输出1到10中的奇数。
在嵌套循环中，continue同样默认作用于最内层循环。例如：
for (let i = 1; i <= 3; i++) {
for (let j = 1; j <= 3; j++) {
if (i === 2 && j === 2) {
continue;
}
console.log(i + ','+ j);
}
}
这里当i为2且j为2时，跳过本次内层循环的console.log(i + ','+ j)，但内层循环会继续，输出结果为：
1, 1
1, 2
1, 3
2, 1
2, 3
3, 1
3, 2
3, 3
如果要对多层循环起作用，也可以使用标签来指定作用的循环。例如：
outer:
for (let i = 1; i <= 3; i++) {
for (let j = 1; j <= 3; j++) {
if (i === 2 && j === 2) {
continue outer;
}
console.log(i + ','+ j);
}
}
这样当i为2且j为2时，会跳过外层循环的剩余部分，直接开始下一次外层循环，输出结果为：
1, 1
1, 2
1, 3
3, 1
3, 2
3, 3
通过对这些控制流语句的掌握，开发者可以根据不同的业务需求，灵活地控制JavaScript代码的执行流程，编写出更高效、更灵活的程序。无论是简单的条件判断，还是复杂的循环嵌套，这些语句都是构建强大JavaScript应用的基础。在实际开发中，需要根据具体情况选择合适的控制流语句，并注意代码的可读性和可维护性，避免过度复杂的嵌套和不恰当的使用，以确保程序的稳健运行。例如，在处理大量数据的循环中，合理使用break和continue可以优化程序的执行效率，避免不必要的计算。同时，在使用switch语句时，要注意break的正确使用，防止穿透现象带来的意外结果。对于for...of和for...in的区别，要根据遍历的对象类型和需求准确选择，以获取正确的遍历结果。总之，熟练掌握这些控制流语句是JavaScript开发者必备的技能之一。