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

Table of Contents

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
);

原创文章，作者：huoxiaoqiang，如若转载，请注明出处：https://www.huoxiaoqiang.com/javascript/javascriptlang/4582.html