【JavaScript-Day 12】掌握程序流程：深入解析 if...else 条件语句

于 2025-05-15 09:00:00 发布
阅读量816 收藏 15
点赞数 13
分类专栏： Java编程全景指南：从零到精通 文章标签： javascript 开发语言 ecmascript java 前端 后端 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kiradzy/article/details/147963897
版权

Langchain系列文章目录

01-玩转LangChain：从模型调用到Prompt模板与输出解析的完整指南
02-玩转 LangChain Memory 模块：四种记忆类型详解及应用场景全覆盖
03-全面掌握 LangChain：从核心链条构建到动态任务分配的实战指南
04-玩转 LangChain：从文档加载到高效问答系统构建的全程实战
05-玩转 LangChain：深度评估问答系统的三种高效方法（示例生成、手动评估与LLM辅助评估）
06-从 0 到 1 掌握 LangChain Agents：自定义工具 + LLM 打造智能工作流！
07-【深度解析】从GPT-1到GPT-4：ChatGPT背后的核心原理全揭秘
08-【万字长文】MCP深度解析：打通AI与世界的“USB-C”，模型上下文协议原理、实践与未来

Python系列文章目录

PyTorch系列文章目录

机器学习系列文章目录

深度学习系列文章目录

Java系列文章目录

JavaScript系列文章目录

01-【JavaScript-Day 1】从零开始：全面了解 JavaScript 是什么、为什么学以及它与 Java 的区别
02-【JavaScript-Day 2】开启 JS 之旅：从浏览器控制台到 ＜script＞ 标签的 Hello World 实践
03-【JavaScript-Day 3】掌握JS语法规则：语句、分号、注释与大小写敏感详解
04-【JavaScript-Day 4】var 完全指南：掌握变量声明、作用域及提升
05-【JavaScript-Day 5】告别 var 陷阱：深入理解 let 和 const 的妙用
06-【JavaScript-Day 6】从零到精通：JavaScript 原始类型 String, Number, Boolean, Null, Undefined, Symbol, BigInt 详解
07-【JavaScript-Day 7】全面解析 Number 与 String：JS 数据核心操作指南
08-【JavaScript-Day 8】告别混淆：一文彻底搞懂 JavaScript 的 Boolean、null 和 undefined
09-【JavaScript-Day 9】从基础到进阶：掌握 JavaScript 核心运算符之算术与赋值篇
10-【JavaScript-Day 10】掌握代码决策核心：详解比较、逻辑与三元运算符
11-【JavaScript-Day 11】避坑指南！深入理解JavaScript隐式和显式类型转换
12-【JavaScript-Day 12】掌握程序流程：深入解析 if…else 条件语句

文章目录

前言

欢迎来到 JavaScript 学习系列的第 12 天！在之前的学习中，我们已经掌握了 JavaScript 的基本语法、变量、数据类型以及运算符。今天，我们将进入一个非常关键的领域——条件语句。想象一下，如果我们的程序只能从头到尾一条路走到黑，那将是多么的单调和局限。条件语句赋予了程序“思考”和“选择”的能力，让代码能够根据不同的情况执行不同的路径，这正是程序智能化的第一步。本文将带你深入理解 JavaScript 中最核心的条件控制结构：if...else 语句，包括其基本用法、多条件判断以及嵌套逻辑，助你轻松掌握程序流程控制的精髓。

一、什么是条件语句？

在编写程序时，我们经常需要根据特定条件来决定执行哪些代码。例如，用户登录时，我们需要判断输入的密码是否正确，如果正确则允许登录，否则提示错误。这种根据条件执行不同操作的机制，就是通过条件语句来实现的。

1.1 程序执行的岔路口

你可以将条件语句想象成现实生活中的岔路口。当你走到一个岔路口时，通常会有一个指示牌或一个判断依据（比如“向左通往A地，向右通往B地”）。你会根据这个“条件”（你的目的地是A还是B）来选择走哪条路。

在程序中，这个“条件”通常是一个结果为布尔值（true 或 false）的表达式。如果条件为 true，程序就执行一条路径上的代码；如果条件为 false，程序就可能执行另一条路径上的代码，或者什么也不做，继续往下执行。

1.2 JavaScript 中的条件控制

JavaScript 提供了多种条件控制语句，其中最常用和最基础的就是 if...else 系列语句。它们允许我们根据一个或多个条件的真假来决定代码的执行流程。

主要包括以下几种形式：

  • if 语句：当指定条件为真时，执行特定代码块。
  • if...else 语句：当指定条件为真时执行一个代码块，为假时执行另一个代码块。
  • if...else if...else 语句：用于检查多个条件，并执行与第一个真条件对应的代码块。
  • 嵌套 if 语句：在一个 if 或 else 语句内部再包含另一个 if 语句，用于处理更复杂的逻辑。

接下来，我们将逐一详细学习这些语句。

二、if 语句：满足条件则执行

if 语句是最基本的条件语句。它的核心思想是：如果（if）某个条件成立，那么就执行指定的代码块。

2.1 基本语法结构

if 语句的语法结构非常简洁：

if (condition) {
  // 当 condition 为 true 时执行这里的代码
  // 这个代码块被称为 "if 子句" 或 "then 子句"
}
// 如果 condition 为 false，则跳过花括号内的代码，继续执行这里的代码
  • if：关键字，表示这是一个条件判断的开始。
  • condition：括号内的表达式，其结果会被转换为布尔值。如果结果为 true（或可以被转换为 true 的“真值”，如非零数字、非空字符串等），则执行花括号 {} 内的代码块。如果结果为 false（或可以被转换为 false 的“假值”，如 0、空字符串 ""、null、undefined、NaN），则跳过花括号内的代码块。
  • { ... }：花括号定义了一个代码块，其中包含一条或多条在条件满足时需要执行的 JavaScript 语句。

2.2 工作原理

if 语句的执行流程可以用下面的流程图来表示：

graph TD
    A[开始] --> B{条件 (condition) 是否为 true?};
    B -- 是 (true) --> C[执行 if 代码块];
    B -- 否 (false) --> D[跳过 if 代码块，执行后续代码];
    C --> D;

当程序执行到 if 语句时：

  1. 首先计算 condition 表达式的值。
  2. 如果该值为 true (或等效于 true)，则执行花括号 {} 内的代码块。
  3. 如果该值为 false (或等效于 false)，则跳过花括号 {} 内的代码块。
  4. 无论条件是否满足，程序都会继续执行 if 语句之后的代码（除非 if 块内有跳转语句，如 return）。

2.3 代码示例与解读

让我们通过一个具体的例子来理解 if 语句。

（1）场景：判断用户是否成年

假设我们需要根据用户年龄判断其是否成年（通常以18岁为界）。

（2）代码实现
let userAge = 20; // 假设用户年龄为20岁

if (userAge >= 18) {
  console.log("您已成年，可以访问该内容。"); // 条件为真时执行
}

console.log("程序继续执行..."); // if语句之后的代码

let minorAge = 15;
if (minorAge >= 18) {
  console.log("这是一个未成年人，这条消息不应该显示。"); // 条件为假，此块不执行
}
（3）结果分析

在上面的代码中：

  1. 对于 userAge = 20：
    • 条件 userAge >= 18 (即 20 >= 18) 的结果是 true。
    • 因此，花括号内的 console.log("您已成年，可以访问该内容。"); 会被执行。
    • 控制台会输出：“您已成年，可以访问该内容。”
    • 然后继续执行下一句，输出：“程序继续执行…”
  2. 对于 minorAge = 15：
    • 条件 minorAge >= 18 (即 15 >= 18) 的结果是 false。
    • 因此，花括号内的 console.log(...) 不会被执行。
    • 程序直接跳过 if 代码块。

2.4 注意事项

（1）条件表达式的求值

if 语句的条件部分不仅仅接受纯粹的布尔值 true 或 false。JavaScript 会对条件表达式的结果进行隐式类型转换，将其转换为布尔值。

  • Truthy 值：所有在布尔上下文中被视为 true 的值。例如，非零数字 (1, -10), 非空字符串 ("hello", "false"), 对象 ({}), 数组 ([]) 等。
  • Falsy 值：所有在布尔上下文中被视为 false 的值。包括 false, 0, "" (空字符串), null, undefined, NaN。
if (0) {
  console.log("0 is truthy"); // 不会执行，因为 0 是 falsy
}
if ("") {
  console.log("Empty string is truthy"); // 不会执行，因为 "" 是 falsy
}
if (null) {
  console.log("null is truthy"); // 不会执行，因为 null 是 falsy
}
if ([]) { // 注意：空数组是 truthy!
  console.log("Empty array is truthy"); // 会执行
}
if ({}) { // 注意：空对象是 truthy!
  console.log("Empty object is truthy"); // 会执行
}

理解 Truthy 和 Falsy 值对于编写正确的条件判断非常重要。

（2）代码块的花括号

虽然当 if 语句后面只有一条执行语句时，可以省略花括号 {}，但强烈建议始终使用花括号。

不使用花括号的写法（不推荐）：

if (userAge >= 18)
  console.log("已成年"); // 只有这一句受 if 控制
console.log("检查完毕"); // 这一句不受 if 控制，总会执行

如果之后想在条件为真时添加更多操作，很容易忘记添加花括号，导致逻辑错误：

let isMember = true;
if (isMember)
  console.log("欢迎会员！");
  // 错误！这行代码无论 isMember 是 true 还是 false 都会执行，因为它不在 if 的控制范围内
  // 看起来像是 if 的一部分，但实际上不是。
  // sendWelcomeEmail(); // 假设这是后来添加的，意图是会员才发送

正确的做法（推荐）：

let isMember = true;
if (isMember) {
  console.log("欢迎会员！");
  // sendWelcomeEmail(); // 现在这行代码也受 if 控制
}

始终使用花括号可以提高代码的清晰度和可维护性，避免潜在的逻辑错误。

三、if...else 语句：两种选择

当我们需要在条件成立时执行一段代码，在条件不成立时执行另一段代码时，就需要用到 if...else 语句。它提供了“如果…那么…否则…”的逻辑。

3.1 基本语法结构

if...else 语句的语法结构如下：

if (condition) {
  // 当 condition 为 true 时执行这里的代码 (if 代码块)
} else {
  // 当 condition 为 false 时执行这里的代码 (else 代码块)
}
  • if (condition) { ... } 部分与单独的 if 语句相同。
  • else：关键字，表示“否则”。当 if 的 condition 为 false 时，程序会执行 else 关键字后面的代码块。
  • else 代码块不需要条件，它是在 if 条件不满足时的默认执行路径。

3.2 工作原理

if...else 语句的执行流程确保两个代码块中只有一个会被执行：

graph TD
    A[开始] --> B{条件 (condition) 是否为 true?};
    B -- 是 (true) --> C[执行 if 代码块];
    B -- 否 (false) --> D[执行 else 代码块];
    C --> E[结束或执行后续代码];
    D --> E;
  1. 计算 condition 表达式的值。
  2. 如果值为 true，执行 if 后面的代码块，然后跳过 else 代码块。
  3. 如果值为 false，跳过 if 后面的代码块，执行 else 后面的代码块。
  4. 执行完毕后，程序继续执行 if...else 结构之后的代码。

3.3 代码示例与解读

（1）场景：判断数字是奇数还是偶数

一个经典的 if...else 应用场景是判断一个整数是奇数还是偶数。

（2）代码实现
let number = 7;

if (number % 2 === 0) { // '%' 是取模运算符，返回除法的余数
  console.log(number + " 是一个偶数。");
} else {
  console.log(number + " 是一个奇数。");
}

number = 10;
if (number % 2 === 0) {
  console.log(number + " 是一个偶数。");
} else {
  console.log(number + " 是一个奇数。");
}
（3）结果分析
  • 当 number 为 7 时：
    • 条件 number % 2 === 0 (即 7 % 2 === 0，1 === 0) 为 false。
    • 程序跳过 if 代码块，执行 else 代码块中的 console.log(number + " 是一个奇数。");。
    • 输出：“7 是一个奇数。”
  • 当 number 为 10 时：
    • 条件 number % 2 === 0 (即 10 % 2 === 0，0 === 0) 为 true。
    • 程序执行 if 代码块中的 console.log(number + " 是一个偶数。");，然后跳过 else 代码块。
    • 输出：“10 是一个偶数。”

if...else 结构保证了对于任何给定的 number，两条 console.log 消息中只有一条会被打印。

四、if...else if...else 语句：多重条件判断

当我们需要从多个条件中选择一个来执行时，可以使用 if...else if...else 结构。这允许我们按顺序检查一系列条件，并执行第一个满足条件的语句块。

4.1 基本语法结构

if (condition1) {
  // 当 condition1 为 true 时执行这里的代码
} else if (condition2) {
  // 当 condition1 为 false 且 condition2 为 true 时执行这里的代码
} else if (condition3) {
  // 当 condition1 和 condition2 都为 false 且 condition3 为 true 时执行这里的代码
} // ... 可以有更多的 else if 块
else {
  // 当以上所有条件都为 false 时执行这里的代码 (可选)
}
  • 程序会从上到下依次检查每个 condition。
  • 一旦找到一个为 true 的 condition，对应的代码块会被执行，然后整个 if...else if...else 结构结束，后续的 else if 或 else 块都会被跳过。
  • 如果所有的 if 和 else if 条件都为 false，那么最后的 else 代码块（如果存在）会被执行。
  • 最后的 else 块是可选的。如果没有 else 块，并且所有条件都为 false，那么整个结构将不执行任何代码块。

4.2 工作原理

if...else if...else 语句的执行流程如下：

graph TD
    A[开始] --> B{条件1成立?};
    B -- 是 (true) --> C[执行 if 代码块];
    B -- 否 (false) --> D{条件2成立?};
    D -- 是 (true) --> E[执行 else if (2) 代码块];
    D -- 否 (false) --> F{...更多条件...};
    F -- 是 (true) --> G[执行相应 else if 代码块];
    F -- 否 (false) --> H[执行 else 代码块 (若有)];
    C --> Z[结束或执行后续代码];
    E --> Z;
    G --> Z;
    H --> Z;
    I[所有条件不成立且无else] --> Z;
    F -- 所有条件不成立 --> I;

(简化版，展示核心逻辑)

4.3 代码示例与解读

（1）场景：根据分数评定等级

假设我们需要根据学生的考试分数来评定等级：

  • 90分及以上：优秀
  • 80-89分：良好
  • 70-79分：中等
  • 60-69分：及格
  • 60分以下：不及格
（2）代码实现
let score = 75;
let grade;

if (score >= 90) {
  grade = "优秀";
} else if (score >= 80) { // 能进入这里，说明 score < 90
  grade = "良好";
} else if (score >= 70) { // 能进入这里，说明 score < 80
  grade = "中等";
} else if (score >= 60) { // 能进入这里，说明 score < 70
  grade = "及格";
} else { // 能进入这里，说明 score < 60
  grade = "不及格";
}

console.log("您的分数是 " + score + "，等级是：" + grade); // 输出：您的分数是 75，等级是：中等
（3）结果分析

当 score 为 75 时：

  1. score >= 90 ( 75 >= 90 ) 为 false。
  2. 接着判断 score >= 80 ( 75 >= 80 ) 为 false。
  3. 接着判断 score >= 70 ( 75 >= 70 ) 为 true。
    • 执行 grade = "中等";。
    • 后续的 else if (score >= 60) 和 else 块被跳过。
  4. 最后输出结果。

重要提示：else if 条件的顺序非常重要。如果顺序不当，可能会导致逻辑错误。例如，如果把 score >= 60 放在 score >= 70 之前，那么一个75分的学生也会被错误地评为“及格”。

4.4 else if 的数量

你可以根据需要使用任意数量的 else if 块，以覆盖所有可能的条件分支。最后的 else 块也是可选的，用于处理所有其他未明确列出的情况。

五、嵌套 if 语句：更复杂的逻辑

当一个条件判断的逻辑依赖于另一个条件判断的结果时，我们可以在一个 if 语句（或 else if、else 语句）的内部再嵌入另一个 if 语句，这就是嵌套 if 语句。

5.1 什么是嵌套 if？

嵌套 if 允许我们构建更细致、更复杂的条件逻辑。外层 if 控制一个较大的条件，内层 if 在外层条件满足（或不满足）的前提下，进行进一步的判断。

5.2 语法结构示例

if (outerCondition) {
  // 外层条件为 true 时执行
  console.log("外层条件满足。");

  if (innerCondition1) {
    // 外层条件为 true 且内层条件1为 true 时执行
    console.log("内层条件1也满足。");
  } else if (innerCondition2) {
    // 外层条件为 true 且内层条件1为 false，但内层条件2为 true 时执行
    console.log("内层条件1不满足，但内层条件2满足。");
  } else {
    // 外层条件为 true 且内层所有条件都不满足时执行
    console.log("内层所有条件均不满足。");
  }

} else {
  // 外层条件为 false 时执行
  console.log("外层条件不满足。");
}

5.3 代码示例与解读

（1）场景：活动资格判断

假设一个电商网站搞活动，规则如下：

  1. 用户必须是会员。
  2. 如果是会员：
    • 如果消费满 200 元，则享受八折优惠。
    • 如果消费满 100 元但不足 200 元，则享受九折优惠。
    • 如果消费不足 100 元，则无额外优惠。
  3. 如果不是会员，则无任何优惠。
（2）代码实现
let isMember = true;
let purchaseAmount = 150;
let discount = 1.0; // 默认为无折扣 (100%)

if (isMember) {
  console.log("欢迎会员！正在检查您的消费金额...");
  if (purchaseAmount >= 200) {
    discount = 0.8; // 八折
    console.log("您消费满200元，享受八折优惠！");
  } else if (purchaseAmount >= 100) {
    discount = 0.9; // 九折
    console.log("您消费满100元，享受九折优惠！");
  } else {
    console.log("您的消费金额未达到优惠标准。");
  }
} else {
  console.log("抱歉，此活动仅限会员参与。");
}

let finalPrice = purchaseAmount * discount;
console.log("您的最终支付金额是：" + finalPrice.toFixed(2) + "元");
（3）结果分析

若 isMember = true 且 purchaseAmount = 150：

  1. 外层 if (isMember) 条件为 true。输出 “欢迎会员！正在检查您的消费金额…”。
  2. 进入内层 if 判断：
    • purchaseAmount >= 200 ( 150 >= 200 ) 为 false。
    • purchaseAmount >= 100 ( 150 >= 100 ) 为 true。
      • discount 被设置为 0.9。
      • 输出 “您消费满100元，享受九折优惠！”。
      • 内层 else 被跳过。
  3. 外层 else 被跳过。
  4. 计算 finalPrice = 150 * 0.9 = 135。
  5. 输出 “您的最终支付金额是：135.00元”。

5.4 使用嵌套 if 的注意事项

（1）代码可读性

过多的嵌套（例如超过2-3层）会使代码难以阅读和理解。如果发现嵌套过深，可以考虑以下优化方法：

  • 使用逻辑运算符 (&&, ||, !)：将一些内层条件合并到外层条件中。
  • 提取为函数：将内层的逻辑封装成一个独立的函数，使主 if 结构更清晰。
  • 使用 switch 语句：在某些情况下，如果判断基于同一个变量的多个值，switch 语句可能更清晰。
  • 提前返回 (Guard Clauses)：在函数中，对于不满足主要逻辑的条件，可以尽早使用 if 判断并 return，避免深层嵌套。

例如，对于上述活动资格判断，如果只关心最终折扣，可以扁平化一些：

// 扁平化尝试（使用逻辑与 &&）
if (isMember && purchaseAmount >= 200) {
    discount = 0.8;
} else if (isMember && purchaseAmount >= 100) {
    discount = 0.9;
} else if (!isMember) {
    // 处理非会员情况
} // ... 逻辑可能需要重新组织

选择哪种方式取决于具体场景和哪个能带来更好的可读性。

（2）逻辑复杂度

嵌套 if 会增加代码的逻辑复杂度。务必仔细测试所有可能的路径，确保逻辑正确无误。使用清晰的变量名和适当的注释有助于管理这种复杂性。

六、常见问题与最佳实践

在使用 if...else 语句时，有一些常见的错误和可以提升代码质量的最佳实践。

6.1 忘记 else

有时候，我们只需要在某个条件满足时执行操作，不满足时则什么也不做。这时，单独的 if 语句就足够了。但如果存在两种互斥的可能，并且都需要处理，那么 if...else 更为合适。

错误地认为所有 if 都需要 else，或者在只需要 if 的地方画蛇添足地加上一个空的 else 块，都是不必要的。

6.2 条件表达式的常见错误

（1）使用赋值运算符 = 而不是比较运算符 == 或 ===

这是一个非常常见且隐蔽的错误。

let x = 10;
if (x = 5) { // 错误！这里是赋值操作，不是比较
  // x 被赋值为 5，然后 if(5) 求值为 true
  console.log("x is 5"); // 这条语句总是会执行（除非x被赋值为falsy值）
}
console.log(x); // 输出 5，而不是初始的 10

正确的比较应该是：

let x = 10;
if (x === 5) { // 正确！使用严格相等运算符
  console.log("x is 5");
}

或者 x == 5 (非严格相等，会进行类型转换)。推荐优先使用 === (严格相等) 和 !== (严格不等) 来避免因类型转换带来的意外行为。

（2）复杂的布尔逻辑

当条件包含多个逻辑运算符 (&&, ||, !) 时，如果不确定优先级，或者想让逻辑更清晰，应该使用圆括号 () 来明确组合顺序。

// 不清晰
if (age > 18 && isStudent || isAdmin) { /* ... */ }

// 清晰
if ((age > 18 && isStudent) || isAdmin) { /* ... */ } // 学生且成年，或者是管理员
// 或者
if (age > 18 && (isStudent || isAdmin)) { /* ... */ } // 成年，并且是学生或是管理员

不同的括号组合会导致完全不同的逻辑。

6.3 提高可读性的技巧

（1）清晰的条件

条件表达式应尽可能简洁明了。如果一个条件过于复杂，可以考虑将其结果赋给一个具有描述性名称的布尔变量。

// 不太清晰
if ((user.role === 'editor' || user.role === 'admin') && user.isActive && article.status === 'published') {
  // ...
}

// 更清晰
const canEditPublishedArticle = (user.role === 'editor' || user.role === 'admin') &&
                                user.isActive &&
                                article.status === 'published';
if (canEditPublishedArticle) {
  // ...
}
（2）适当的缩进和格式化

保持一致的缩进和代码格式化对于阅读 if...else 结构至关重要。大多数代码编辑器都有自动格式化功能。

（3）使用三元运算符简化

对于简单的 if...else 赋值或返回，可以使用三元条件运算符 (condition ? exprIfTrue : exprIfFalse) 来使代码更简洁。我们在第10天的运算符学习中接触过它。

// 使用 if...else
let accessAllowed;
if (age >= 18) {
  accessAllowed = true;
} else {
  accessAllowed = false;
}

// 使用三元运算符
let accessAllowedTernary = (age >= 18) ? true : false;
// 甚至更简单，因为比较运算本身返回布尔值
let accessAllowedSimple = (age >= 18);

// 另一个例子
let message;
if (isLoggedIn) {
  message = "Welcome back!";
} else {
  message = "Please log in.";
}

// 使用三元运算符
let messageTernary = isLoggedIn ? "Welcome back!" : "Please log in.";

但注意不要滥用三元运算符，如果逻辑变得复杂，if...else 通常更易读。

（4）避免深度嵌套

如前所述，尽量避免超过2-3层的 if 嵌套。可以考虑使用函数、逻辑运算符优化或提前返回等策略来扁平化结构。

七、总结

今天，我们系统地学习了 JavaScript 中的核心流程控制语句——if...else 及其变体。掌握它们是编写能够根据不同情况做出不同反应的动态程序的基石。

核心内容回顾：

  • if 语句：用于当单个条件满足时执行代码块。语法为 if (condition) { ... }。
  • if...else 语句：用于在条件满足时执行一个代码块，不满足时执行另一个代码块，提供二选一的逻辑。语法为 if (condition) { ... } else { ... }。
  • if...else if...else 语句：用于按顺序检查多个条件，并执行第一个为真条件对应的代码块，最后的 else (可选) 处理所有其他情况。语法为 if (c1) { ... } else if (c2) { ... } else { ... }。
  • 嵌套 if 语句：允许在 if 或 else 块内部再使用 if 语句，以处理更复杂的、层级化的条件逻辑。
  • 条件求值：JavaScript 会将条件表达式转换为布尔值，理解 Truthy 和 Falsy 值非常重要。
  • 代码规范：始终使用花括号 {} 包围代码块，注意比较运算符 (===) 与赋值运算符 (=) 的区别，以及通过清晰的条件和合理的结构提高代码可读性。

通过今天的学习，你应该能够自如地运用这些条件语句来控制程序的流程了。在接下来的学习中，我们还会接触到另一种重要的条件语句 switch，以及循环语句，它们将进一步增强你构建复杂应用的能力。记得多加练习，将理论知识转化为实际编码能力！

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

吴师兄大模型

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值