跳到主要内容

JavaScript 关键字

JavaScript语言中的关键字是保留字,具有特殊含义和用途。这些关键字是语言的基础,定义了JavaScript代码的结构和行为。作为初学者,了解这些关键字对掌握JavaScript编程至关重要。

什么是JavaScript关键字?

JavaScript关键字是语言本身预定义的标识符,用于执行特定的任务,如声明变量、控制程序流程或定义函数。这些关键字不能用作变量名、函数名或其他标识符名称。

注意

关键字是JavaScript语法的一部分,不能被重新定义或用作标识符。

JavaScript 关键字列表

以下是JavaScript中的关键字列表,按功能分类:

变量声明关键字

javascript
// var - 函数作用域变量声明
var x = 5;
console.log(x); // 输出: 5

// let - 块级作用域变量声明
let y = 10;
console.log(y); // 输出: 10

// const - 常量声明(块级作用域)
const PI = 3.14159;
console.log(PI); // 输出: 3.14159

varletconst之间的主要区别:

  1. 作用域var是函数作用域,而letconst是块级作用域。
  2. 变量提升var声明的变量会被提升,而letconst不会。
  3. 重新声明:在同一作用域内,var可以重新声明同名变量,而letconst不能。
  4. 修改值varlet声明的变量值可以修改,而const声明的是常量,其值不能被重新赋值。

条件语句关键字

javascript
// if-else语句
let age = 18;
if (age >= 18) {
console.log("成年人"); // 输出: 成年人
} else {
console.log("未成年人");
}

// switch语句
let fruit = "苹果";
switch(fruit) {
case "香蕉":
console.log("黄色水果");
break;
case "苹果":
console.log("红色水果"); // 输出: 红色水果
break;
default:
console.log("未知水果");
}

循环关键字

javascript
// for循环
for (let i = 0; i < 3; i++) {
console.log(i); // 输出: 0, 1, 2
}

// while循环
let count = 0;
while (count < 3) {
console.log(count); // 输出: 0, 1, 2
count++;
}

// do-while循环
let num = 0;
do {
console.log(num); // 输出: 0, 1, 2
num++;
} while (num < 3);

// for...in循环(用于对象属性)
let person = {name: "张三", age: 30};
for (let key in person) {
console.log(key + ": " + person[key]); // 输出: name: 张三, age: 30
}

// for...of循环(用于可迭代对象)
let colors = ["红", "绿", "蓝"];
for (let color of colors) {
console.log(color); // 输出: 红, 绿, 蓝
}

函数声明关键字

javascript
// function - 函数声明
function greet() {
return "你好!";
}
console.log(greet()); // 输出: 你好!

// return - 返回值
function add(a, b) {
return a + b;
}
console.log(add(2, 3)); // 输出: 5

异常处理关键字

javascript
// try-catch-finally
try {
// 尝试执行可能会出错的代码
let result = 10 / 0;
console.log(result); // 输出: Infinity(JavaScript中除以0不会抛出异常)

// 手动抛出异常
throw new Error("发生了一个错误");
} catch (error) {
// 捕获并处理异常
console.log("捕获到异常: " + error.message); // 输出: 捕获到异常: 发生了一个错误
} finally {
// 无论是否有异常,都会执行的代码
console.log("异常处理完成"); // 输出: 异常处理完成
}

对象操作关键字

javascript
// new - 创建对象实例
let date = new Date();
console.log(date); // 输出: 当前日期和时间

// this - 引用当前上下文
let user = {
name: "李四",
greet: function() {
return "你好," + this.name;
}
};
console.log(user.greet()); // 输出: 你好,李四

// class - ES6中的类声明
class Person {
constructor(name) {
this.name = name;
}

sayHello() {
return `你好,我是${this.name}`;
}
}

let person = new Person("王五");
console.log(person.sayHello()); // 输出: 你好,我是王五

其他重要关键字

javascript
// typeof - 检查数据类型
console.log(typeof "Hello"); // 输出: string
console.log(typeof 123); // 输出: number

// instanceof - 检查对象是否为特定类的实例
let arr = [1, 2, 3];
console.log(arr instanceof Array); // 输出: true

// in - 检查属性是否存在于对象中
let car = {make: "丰田", model: "卡罗拉"};
console.log("make" in car); // 输出: true
console.log("color" in car); // 输出: false

// delete - 删除对象属性
delete car.model;
console.log(car); // 输出: {make: "丰田"}

// void - 计算表达式但不返回值
console.log(void 0); // 输出: undefined

保留字

除了当前使用的关键字外,JavaScript还有一些保留字,这些词可能在将来的JavaScript版本中成为关键字,因此也不建议用作标识符:

abstract, boolean, byte, char, double, final, float, goto, 
int, long, native, short, synchronized, throws, transient,
volatile

实际应用案例

案例1:使用关键字构建简单计算器

javascript
function calculator() {
try {
const operation = prompt("请输入运算符(+、-、*、/):");
const num1 = parseFloat(prompt("请输入第一个数字:"));
const num2 = parseFloat(prompt("请输入第二个数字:"));

let result;

switch(operation) {
case "+":
result = num1 + num2;
break;
case "-":
result = num1 - num2;
break;
case "*":
result = num1 * num2;
break;
case "/":
if(num2 === 0) {
throw new Error("除数不能为零!");
}
result = num1 / num2;
break;
default:
throw new Error("不支持的运算符!");
}

return `${num1} ${operation} ${num2} = ${result}`;

} catch(error) {
return "计算错误: " + error.message;
}
}

// 调用时会显示提示框让用户输入,然后返回计算结果

案例2:使用关键字实现购物车功能

javascript
class CartItem {
constructor(name, price, quantity) {
this.name = name;
this.price = price;
this.quantity = quantity;
}

getTotal() {
return this.price * this.quantity;
}
}

class ShoppingCart {
constructor() {
this.items = [];
}

addItem(name, price, quantity) {
const existingItem = this.items.find(item => item.name === name);

if (existingItem) {
existingItem.quantity += quantity;
} else {
this.items.push(new CartItem(name, price, quantity));
}
}

removeItem(name) {
const index = this.items.findIndex(item => item.name === name);
if (index !== -1) {
this.items.splice(index, 1);
return true;
}
return false;
}

getTotal() {
let total = 0;
for (const item of this.items) {
total += item.getTotal();
}
return total;
}

displayCart() {
if (this.items.length === 0) {
return "购物车为空";
}

let cartDisplay = "购物车内容:\n";
for (const item of this.items) {
cartDisplay += `${item.name} - 单价: ¥${item.price} - 数量: ${item.quantity} - 小计: ¥${item.getTotal()}\n`;
}
cartDisplay += `总计: ¥${this.getTotal()}`;

return cartDisplay;
}
}

// 使用示例
const cart = new ShoppingCart();
cart.addItem("笔记本电脑", 5999, 1);
cart.addItem("键盘", 299, 2);
console.log(cart.displayCart());
// 输出:
// 购物车内容:
// 笔记本电脑 - 单价: ¥5999 - 数量: 1 - 小计: ¥5999
// 键盘 - 单价: ¥299 - 数量: 2 - 小计: ¥598
// 总计: ¥6597

关键字的最佳实践

  1. 避免命名冲突:永远不要使用关键字作为变量名或函数名。
  2. 使用严格模式:通过在代码顶部添加 "use strict"; 启用严格模式,可以避免一些常见错误。
  3. 优先使用现代关键字:优先使用 letconst 而不是 var
  4. 尊重作用域规则:了解并尊重不同关键字的作用域规则。
  5. 选择合适的控制结构:根据需要选择最合适的循环和条件语句结构。

总结

JavaScript关键字是语言的基本构建块,掌握这些关键字及其用法对编写有效的JavaScript代码至关重要。通过本文,我们了解了:

  • 什么是JavaScript关键字以及为什么它们很重要
  • 各类关键字的分类和用法
  • 如何在实际开发中正确使用这些关键字
  • 关键字相关的最佳实践

随着你继续学习JavaScript,你会发现这些关键字如何构成更复杂的程序结构,并使你能够构建功能丰富的应用程序。

练习题

为了巩固你对JavaScript关键字的理解,尝试完成以下练习:

  1. 创建一个使用不同循环关键字(for, while, do...while)的程序,每个循环打印出1到5的数字。
  2. 编写一个函数,使用条件关键字检查用户输入的年龄,并根据年龄返回不同的消息。
  3. 创建一个对象,并使用对象相关的关键字(this, new, class等)进行操作。
  4. 编写一个简单的程序,演示try-catch-finally块的使用。
扩展阅读

要进一步了解JavaScript关键字,可以查阅MDN Web文档:JavaScript 参考