JavaScript语句

在本章节中，我们将学习JavaScript语句的相关知识，包括语句的定义、类型和使用方法，以及如何使用语句控制程序流程。

1. 什么是语句？

语句是JavaScript中用于执行操作的代码片段，它可以控制程序的流程、定义变量、声明函数等。与表达式不同，语句不一定产生值，而是用于执行特定的操作。

在JavaScript中，语句通常以分号（;）结尾。分号用于分隔语句，虽然在某些情况下可以省略，但建议始终使用分号，以避免潜在的错误。

// 语句示例
let x = 10; // 变量声明语句
x = x + 5; // 赋值语句
console.log(x); // 函数调用语句

2. 语句的类型

JavaScript语句可以分为多种类型，根据它们的功能来分类。

2.1 声明语句

声明语句用于声明变量或函数。

2.1.1 变量声明语句

使用var、let或const关键字声明变量。

// 变量声明语句
var x = 10;
let y = 20;
const PI = 3.14;

// 声明多个变量
let a = 1, b = 2, c = 3;

2.1.2 函数声明语句

使用function关键字声明函数。

// 函数声明语句
function add(a, b) {
    return a + b;
}

// 箭头函数表达式（不是声明语句）
let multiply = (a, b) => a * b;

2.2 条件语句

条件语句用于根据条件执行不同的代码块。

2.2.1 if-else语句

if-else语句用于根据条件执行不同的代码块。

// if语句
let x = 10;
if (x > 5) {
    console.log("x大于5");
}

// if-else语句
if (x > 15) {
    console.log("x大于15");
} else {
    console.log("x小于等于15");
}

// if-else if-else语句
if (x > 15) {
    console.log("x大于15");
} else if (x > 10) {
    console.log("x大于10且小于等于15");
} else if (x > 5) {
    console.log("x大于5且小于等于10");
} else {
    console.log("x小于等于5");
}

2.2.2 switch语句

switch语句用于根据表达式的值选择执行不同的代码块。

let day = 3;
let dayName;

switch (day) {
    case 1:
        dayName = "星期一";
        break;
    case 2:
        dayName = "星期二";
        break;
    case 3:
        dayName = "星期三";
        break;
    case 4:
        dayName = "星期四";
        break;
    case 5:
        dayName = "星期五";
        break;
    case 6:
        dayName = "星期六";
        break;
    case 7:
        dayName = "星期日";
        break;
    default:
        dayName = "无效的星期几";
}

console.log(dayName); // 输出：星期三

2.3 循环语句

循环语句用于重复执行一段代码。

2.3.1 for循环

for循环用于固定次数的循环。

// for循环语法
for (initialization; condition; increment) {
    // 循环体
}

// for循环示例
for (let i = 0; i < 5; i++) {
    console.log(i); // 输出：0, 1, 2, 3, 4
}

// for循环遍历数组
let fruits = ["苹果", "香蕉", "橙子"];
for (let i = 0; i < fruits.length; i++) {
    console.log(fruits[i]); // 输出：苹果, 香蕉, 橙子
}

// for...in循环遍历对象属性
let person = { name: "张三", age: 18, city: "北京" };
for (let key in person) {
    console.log(key + ": " + person[key]); // 输出属性名和值
}

// for...of循环遍历可迭代对象
for (let fruit of fruits) {
    console.log(fruit); // 输出：苹果, 香蕉, 橙子
}

2.3.2 while循环

while循环用于条件为真时重复执行代码。

// while循环语法
while (condition) {
    // 循环体
}

// while循环示例
let i = 0;
while (i < 5) {
    console.log(i); // 输出：0, 1, 2, 3, 4
    i++;
}

2.3.3 do-while循环

do-while循环先执行一次循环体，然后再检查条件。

// do-while循环语法
do {
    // 循环体
} while (condition);

// do-while循环示例
let i = 0;
do {
    console.log(i); // 输出：0, 1, 2, 3, 4
    i++;
} while (i < 5);

2.4 跳转语句

跳转语句用于改变程序的执行流程。

2.4.1 break语句

break语句用于跳出循环或switch语句。

// break语句跳出for循环
for (let i = 0; i < 10; i++) {
    if (i === 5) {
        break; // 当i等于5时，跳出循环
    }
    console.log(i); // 输出：0, 1, 2, 3, 4
}

// break语句跳出while循环
let i = 0;
while (i < 10) {
    if (i === 5) {
        break; // 当i等于5时，跳出循环
    }
    console.log(i); // 输出：0, 1, 2, 3, 4
    i++;
}

// break语句在switch中的使用
let day = 3;
switch (day) {
    case 1:
        console.log("星期一");
        break;
    case 2:
        console.log("星期二");
        break;
    case 3:
        console.log("星期三");
        break; // 跳出switch语句
    // 其他case...
}

2.4.2 continue语句

continue语句用于跳过当前循环的剩余部分，进入下一次循环。

// continue语句跳过当前循环
for (let i = 0; i < 10; i++) {
    if (i % 2 === 0) {
        continue; // 跳过偶数
    }
    console.log(i); // 输出：1, 3, 5, 7, 9
}

// continue语句在while循环中的使用
let i = 0;
while (i < 10) {
    i++;
    if (i % 2 === 0) {
        continue; // 跳过偶数
    }
    console.log(i); // 输出：1, 3, 5, 7, 9
}

2.4.3 return语句

return语句用于从函数中返回值，并终止函数的执行。

// return语句返回值
function add(a, b) {
    return a + b; // 返回a + b的值，并终止函数
    console.log("这行代码不会执行"); // 不会执行
}

let result = add(5, 3); // result的值为8

// return语句不返回值
function greet(name) {
    if (!name) {
        return; // 终止函数，不返回值
    }
    console.log("你好，" + name + "!");
}

// return语句返回对象
function createPerson(name, age) {
    return {
        name: name,
        age: age
    };
}

let person = createPerson("张三", 18);

2.4.4 throw语句

throw语句用于抛出异常。

// throw语句抛出异常
function divide(a, b) {
    if (b === 0) {
        throw new Error("除数不能为零"); // 抛出异常
    }
    return a / b;
}

try {
    let result = divide(10, 0);
    console.log(result);
} catch (error) {
    console.error(error.message); // 输出：除数不能为零
}

2.5 其他语句

2.5.1 try-catch-finally语句

try-catch-finally语句用于处理异常。

// try-catch-finally语句语法
try {
    // 可能抛出异常的代码
} catch (error) {
    // 处理异常的代码
} finally {
    // 无论是否抛出异常，都会执行的代码
}

// try-catch-finally语句示例
try {
    let result = divide(10, 0);
    console.log(result);
} catch (error) {
    console.error("发生错误：" + error.message);
} finally {
    console.log("无论是否发生错误，都会执行这里的代码");
}

2.5.2 with语句

with语句用于简化对对象属性的访问，但不推荐使用，因为它会影响代码的可读性和性能。

// with语句示例
let person = { name: "张三", age: 18, city: "北京" };

with (person) {
    console.log(name); // 等价于console.log(person.name)
    console.log(age); // 等价于console.log(person.age)
    console.log(city); // 等价于console.log(person.city)
}

2.5.3 debugger语句

debugger语句用于在调试器中设置断点。

// debugger语句示例
function add(a, b) {
    debugger; // 在调试器中设置断点
    return a + b;
}

let result = add(5, 3);

3. 语句块

语句块是由花括号{}包围的一组语句，用于将多条语句组合成一个整体。语句块可以用于条件语句、循环语句、函数等。

// 语句块示例
if (x > 5) {
    // 语句块开始
    console.log("x大于5");
    x = x - 5;
    console.log("x现在是：" + x);
    // 语句块结束
}

// 函数中的语句块
function add(a, b) {
    // 语句块开始
    let sum = a + b;
    return sum;
    // 语句块结束
}

4. 严格模式

严格模式是JavaScript的一种执行模式，它提供了更严格的语法规则和错误检查。可以通过在脚本或函数的开头添加"use strict"来启用严格模式。

// 在脚本开头启用严格模式
"use strict";

// 严格模式下的规则
let x = 10;
delete x; // 抛出错误，严格模式下不能删除变量

// 在函数中启用严格模式
function strictFunction() {
    "use strict";
    // 严格模式下的代码
}

严格模式的主要特点：

• 不允许使用未声明的变量
• 不允许删除变量、函数或函数参数
• 不允许重复声明变量
• 不允许使用with语句
• 不允许修改只读属性
• 不允许使用八进制字面量
• 函数参数不能有相同的名称
• 不允许在函数内部使用this指向全局对象

5. 常见语句示例

5.1 条件语句示例

// 检查数字的正负
let num = 10;
if (num > 0) {
    console.log("数字是正数");
} else if (num < 0) {
    console.log("数字是负数");
} else {
    console.log("数字是零");
}

// 根据分数评级
let score = 85;
let grade;
if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else if (score >= 70) {
    grade = "C";
} else if (score >= 60) {
    grade = "D";
} else {
    grade = "F";
}
console.log("分数：" + score + "，等级：" + grade);

5.2 循环语句示例

// 计算1到100的和
let sum = 0;
for (let i = 1; i <= 100; i++) {
    sum += i;
}
console.log("1到100的和：" + sum);

// 打印乘法表
for (let i = 1; i <= 9; i++) {
    let row = "";
    for (let j = 1; j <= i; j++) {
        row += j + "×" + i + "=" + (j * i) + "\t";
    }
    console.log(row);
}

// 查找数组中的最大值
let numbers = [10, 5, 20, 15, 25];
let max = numbers[0];
for (let num of numbers) {
    if (num > max) {
        max = num;
    }
}
console.log("数组中的最大值：" + max);

5.3 跳转语句示例

// 使用break跳出嵌套循环
outerLoop: for (let i = 0; i < 5; i++) {
    for (let j = 0; j < 5; j++) {
        if (i === 2 && j === 2) {
            break outerLoop; // 跳出外层循环
        }
        console.log("i:" + i + ", j:" + j);
    }
}

// 使用continue跳过特定循环
for (let i = 0; i < 10; i++) {
    if (i === 3 || i === 7) {
        continue;
    }
    console.log(i);
}

6. 表达式语句

有些表达式可以作为语句使用，称为表达式语句。表达式语句是通过在表达式后面加上分号来构成的。

// 表达式语句示例
x = 10; // 赋值表达式作为语句
console.log("Hello"); // 函数调用表达式作为语句
x++; // 自增表达式作为语句
add(5, 3); // 函数调用表达式作为语句

7. 常见问题解答

Q: 什么是语句？

A: 语句是JavaScript中用于执行操作的代码片段，它可以控制程序的流程、定义变量、声明函数等。

Q: 语句和表达式有什么区别？

A: 表达式会产生一个值，而语句用于执行操作，不一定产生值。表达式可以作为语句的一部分，例如赋值表达式可以作为赋值语句。

Q: 什么时候使用分号？

A: 语句通常以分号结尾。虽然在某些情况下可以省略分号，但建议始终使用分号，以避免潜在的错误。

Q: break和continue有什么区别？

A: break用于跳出整个循环或switch语句，而continue用于跳过当前循环的剩余部分，进入下一次循环。

Q: for、while和do-while循环有什么区别？

A: for循环适用于已知循环次数的情况，while循环适用于条件为真时重复执行的情况，do-while循环至少执行一次循环体，然后再检查条件。

Q: 什么是严格模式？

A: 严格模式是JavaScript的一种执行模式，它提供了更严格的语法规则和错误检查，可以通过在脚本或函数开头添加"use strict"来启用。

8. 练习项目

1. 创建一个HTML文件，包含以下内容：

   • 一个输入框，用于输入一个数字
   • 一个按钮，用于计算
   • 一个显示结果的区域

2. 使用JavaScript实现以下功能：

   • 点击按钮时，获取输入框的值
   • 使用循环计算该数字的阶乘（n! = n × (n-1) × (n-2) × ... × 1）
   • 显示计算结果
   • 处理可能的错误，如输入非数字或负数

3. 测试不同的输入值，确保计算结果正确

9. 小结

• 语句是JavaScript中用于执行操作的代码片段
• JavaScript语句包括声明语句、条件语句、循环语句、跳转语句等多种类型
• 条件语句用于根据条件执行不同的代码块，包括if-else和switch
• 循环语句用于重复执行代码，包括for、while和do-while
• 跳转语句用于改变程序的执行流程，包括break、continue、return和throw
• 语句块是由花括号包围的一组语句，用于将多条语句组合成一个整体
• 严格模式提供了更严格的语法规则和错误检查，可以提高代码的质量和安全性
• 表达式语句是通过在表达式后面加上分号来构成的

在下一章节中，我们将学习JavaScript作用域的相关知识。