1.9JavaScript语言的条件(Conditional)、循环(Loop)、跳转(Jump)语句

1.if条件

if (条件) {
  //语句;
}

2.if-else条件

if (条件) {
  //语句1;
} else {
  //语句2;
}

3.if-else-if条件

if (条件1) {
  //语句1;
} else if (条件2) {
  //语句2;
} else {
  //语句3;
}

4.switch条件

switch 语句用于将 switchExpression 的值按从上往下的顺序与 caseExpression 的值逐个进行匹配测试，直到 switch 语句结束 或 遇到 break 语句。如果匹配成功，则执行匹配成功的 caseExpression 后的语句。

default 语句非必须有，如果有 default 语句，当 switchExpression 的值匹配不到任何一个 caseExpression 的值 或者 之前的任何一个 caseExpression 后的语句没有遇到 break 语句时，default 语句都会被执行，否则不会被执行。一个 switch 语句只能有一个 default 语句。

注意：匹配测试使用的是全等 === 运算符。

注意：caseExpression 后的花括号可以省略。

switch (switchExpression) {
  case caseExpression1: {
    //语句1;
    [break;]
  }
  case caseExpression2: {
    //语句2;
    [break;]
  }
  case caseExpressionN: {
    //语句N;
    [break;]
  }
  default: {
    //语句;
  }
}

5.while循环

while (条件) {
  //语句;
}

6.do-while循环

do {
  //语句;
}
while (条件);

7.for循环

for (初始表达式;条件表达式;每次迭代后表达式) {
  //语句;
}

let count = 6;
for (let i = 0; i < count; i++) {
  console.log(i);  // 0 1 2 3 4 5
}

let i = 0;
for (const j = 7; i < 5; ++i) {
  console.log(j);  // 7 7 7 7 7
}

8.for-of循环

for-of 语句用于迭代可迭代对象(比如字符串、数组、映射、集合等)中的元素。

注意：for-of 语句是按顺序迭代。

注意：对象字面量不是可迭代对象，但可以通过 Object.entries()、Object.keys()、Object.values() 静态方法将对象字面量返回为数组。

for (赋值表达式左侧 of 同步可迭代对象) {
  //语句;
}

//赋值表达式左侧为变量声明
for (let 变量名 of 同步可迭代对象) {
  //语句;
}

for (let [键, 值] of 同步可迭代对象) {
  //语句;
}

//赋值表达式左侧为常量声明
for (const 常量名 of 同步可迭代对象) {
  //语句;
}

for (const [键, 值] of 同步可迭代对象) {
  //语句;
}

//数组
const arr = [1, 2, 3];

for (const element of arr) {
  console.log(element);  // 1 2 3
}

//对象字面量
const o = { a: 1, b: 2, c: 3 };

for (const [k, v] of Object.entries(o)) {
  console.log(`${k}: ${v}`);
}

//输出
a: 1
b: 2
c: 3

9.for-await-of循环

for-await-of 语句是 for-of 语句的异步版本。

注意：for-await-of 语句只可以被使用在 await 关键字可被使用的地方。

for await (赋值表达式左侧 of 异步或同步可迭代对象) {
  //语句;
}


//赋值表达式左侧为变量声明
for await (let 变量名 of 异步或同步可迭代对象) {
  //语句;
}

for await (let [键, 值] of 异步或同步可迭代对象) {
  //语句;
}


//赋值表达式左侧为常量声明
for await (const 常量名 of 异步或同步可迭代对象) {
  //语句;
}

for await (const [键, 值] of 异步或同步可迭代对象) {
  //语句;
}

//从异步可迭代流中读取数据块并将其打印出来
async function printStream(stream) {
  for await (let chunk of stream) {
    console.log(chunk);
  }
}

10.for-in循环

for-in 语句用于枚举任何对象(包括可迭代对象)中的可枚举的非 Symbol 类型的键。

注意：for-in 语句不一定是按顺序迭代。

for (赋值表达式左侧 in 任何对象) {
  //语句;
}

//赋值表达式左侧为变量声明
for (let 变量名 in 对象) {
  //语句;
}

//赋值表达式左侧为常量声明
for (const 常量名 in 对象) {
  //语句;
}

//数组
const arr = ["a", "b", "c"];

for (const index in arr) {
  console.log(index);  // 0 1 2
}

//对象字面量
const o = { a: 1, b: 2, c: 3 };

for (const p in o) {
  console.log(`${p}: ${o[p]}`);
}

//输出
a: 1
b: 2
c: 3

11.label跳转

label 语句用于给语句加标签。

label : 语句

//outerBlock和innerBlock为标签。
outerBlock: {
  innerBlock: {
    console.log("1");
    break outerBlock;    //跳出outerBlock和innerBlock
    console.log(":-(");  //跳过
  }
  console.log("2");      //跳过
}

//输出
1

12.break跳转

一旦遇到 break; 语句，则立即跳出(break out of)最近的 switch 语句 或 循环语句，并从最近的 switch 语句 或 循环语句外继续向下执行。

一旦遇到 break label; 语句，则立即跳出(break out of) label 语句，并从 label 语句外继续向下执行。

13.continue跳转

一旦遇到 continue; 语句，则立即终止最近的循环语句的本次迭代，继续(continue)最近的循环语句的下一次迭代，并不会完全终止最近的循环语句。

一旦遇到 continue label; 语句，则立即终止带 label 的循环语句的本次迭代，继续(continue)带 label 的循环语句的下一次迭代，并不会完全终止带 label 的循环语句。

14.return跳转

return 语句用于将 return 关键字后的表达式的值返回给函数的调用者。

注意：return 关键字只可以被用在函数体内。

return [表达式];

如果一个函数体内根本没有 return 语句 或者 return 关键字后没有表达式，则会将 undefined 值返回给函数的调用者。

function f1() {
}

function f2() {
  return;
}

f1();  // undefined
f2();  // undefined

如果一个函数体内有多个 return 语句，但一旦遇到第一个 return 语句，函数就会立即停止执行，并将遇到的第一个 return 关键字后的表达式的值返回给函数的调用者。

function f(num) {
  if(num < 0) {
    return "Negative";
  }
  
  if(num > 0) {
    return "Positive";
  }
  
  return 0;
}

f(-8);  // "Negative"
f(0);   // 0
f(8);   // "Positive"

如果想让表达式与 return 关键字不在同一行，又或者表达式太长了想让表达式分多行编写，我们可以将表达式包裹在圆括号 () 内。

return 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9;

return (
  1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9
);

return (
  1 + 2 + 3 +
  4 + 5 + 6 +
  7 + 8 + 9
);

注意：左侧的圆括号 ( 必须和 return 关键字在同一行。比如下面的代码，JavaScript 解释器会认为 return 关键字后有一个逗号 ;，最终导致返回的不是我们期望的表达式的值，而是 undefined 值。

return
(
  1 + 2 + 3 +
  4 + 5 + 6 +
  7 + 8 + 9
);

//同等代码
return;
(
  1 + 2 + 3 +
  4 + 5 + 6 +
  7 + 8 + 9
);