1.8JavaScript语言的条件(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 和 default 后的花括号可以省略。

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 语句的运行顺序为：第一步先计算 条件表达式，如果 条件表达式 为 true，则运行后面的 块语句，然后运行 每次迭代后表达式，依次类推，直至 条件表达式 为 false。

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 (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 arr = [1, 2, 3];

for (const [index, element] of arr.entries()) {
  console.log(`${index}: ${element}`);
}

//输出
0: 1
1: 2
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-in循环

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 key in o) {
  console.log(`${key}: ${o[key]}`);
}

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

10.label跳转

label 语句用于给任何语句加 label。

label 可以是JavaScript 语言支持的任何标识符。

label 语句一般与 break 或者 continue 语句搭配使用。

label : 语句

11.break跳转

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

break;

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

break label;

12.continue跳转

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

continue;

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

continue label;

13.return跳转

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

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

return;
return 表达式;

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

function f1() {
}

function f2() {
  return;
}

console.log(f1());  // undefined
console.log(f2());  // undefined

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

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

console.log(f(-8));  // Negative
console.log(f(0));   // Zero
console.log(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
);